go/src/cmd/internal/gc/swt.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gc

import (
	"cmd/internal/obj"
	"fmt"
)

const (
	Snorm = 0 + iota
	Strue
	Sfalse
	Stype
	Tdefault
	Texprconst
	Texprvar
	Ttypenil
	Ttypeconst
	Ttypevar
	Ncase = 4
)

type Case struct {
	node    *Node
	hash    uint32
	type_   uint8
	diag    uint8
	ordinal uint16
	link    *Case
}

var C *Case

func dumpcase(c0 *Case) {
	for c := c0; c != nil; c = c.link {
		switch c.type_ {
		case Tdefault:
			fmt.Printf("case-default\n")
			fmt.Printf("\tord=%d\n", c.ordinal)

		case Texprconst:
			fmt.Printf("case-exprconst\n")
			fmt.Printf("\tord=%d\n", c.ordinal)

		case Texprvar:
			fmt.Printf("case-exprvar\n")
			fmt.Printf("\tord=%d\n", c.ordinal)
			fmt.Printf("\top=%v\n", Oconv(int(c.node.Left.Op), 0))

		case Ttypenil:
			fmt.Printf("case-typenil\n")
			fmt.Printf("\tord=%d\n", c.ordinal)

		case Ttypeconst:
			fmt.Printf("case-typeconst\n")
			fmt.Printf("\tord=%d\n", c.ordinal)
			fmt.Printf("\thash=%x\n", c.hash)

		case Ttypevar:
			fmt.Printf("case-typevar\n")
			fmt.Printf("\tord=%d\n", c.ordinal)

		default:
			fmt.Printf("case-???\n")
			fmt.Printf("\tord=%d\n", c.ordinal)
			fmt.Printf("\top=%v\n", Oconv(int(c.node.Left.Op), 0))
			fmt.Printf("\thash=%x\n", c.hash)
		}
	}

	fmt.Printf("\n")
}

func ordlcmp(c1 *Case, c2 *Case) int {
	// sort default first
	if c1.type_ == Tdefault {
		return -1
	}
	if c2.type_ == Tdefault {
		return +1
	}

	// sort nil second
	if c1.type_ == Ttypenil {
		return -1
	}
	if c2.type_ == Ttypenil {
		return +1
	}

	// sort by ordinal
	if c1.ordinal > c2.ordinal {
		return +1
	}
	if c1.ordinal < c2.ordinal {
		return -1
	}
	return 0
}

func exprcmp(c1 *Case, c2 *Case) int {
	// sort non-constants last
	if c1.type_ != Texprconst {
		return +1
	}
	if c2.type_ != Texprconst {
		return -1
	}

	n1 := c1.node.Left
	n2 := c2.node.Left

	// sort by type (for switches on interface)
	ct := int(n1.Val.Ctype)

	if ct != int(n2.Val.Ctype) {
		return ct - int(n2.Val.Ctype)
	}
	if !Eqtype(n1.Type, n2.Type) {
		if n1.Type.Vargen > n2.Type.Vargen {
			return +1
		} else {
			return -1
		}
	}

	// sort by constant value
	n := 0

	switch ct {
	case CTFLT:
		n = mpcmpfltflt(n1.Val.U.Fval, n2.Val.U.Fval)

	case CTINT,
		CTRUNE:
		n = Mpcmpfixfix(n1.Val.U.Xval, n2.Val.U.Xval)

	case CTSTR:
		n = cmpslit(n1, n2)
	}

	return n
}

func typecmp(c1 *Case, c2 *Case) int {
	// sort non-constants last
	if c1.type_ != Ttypeconst {
		return +1
	}
	if c2.type_ != Ttypeconst {
		return -1
	}

	// sort by hash code
	if c1.hash > c2.hash {
		return +1
	}
	if c1.hash < c2.hash {
		return -1
	}

	// sort by ordinal so duplicate error
	// happens on later case.
	if c1.ordinal > c2.ordinal {
		return +1
	}
	if c1.ordinal < c2.ordinal {
		return -1
	}
	return 0
}

func csort(l *Case, f func(*Case, *Case) int) *Case {
	if l == nil || l.link == nil {
		return l
	}

	l1 := l
	l2 := l
	for {
		l2 = l2.link
		if l2 == nil {
			break
		}
		l2 = l2.link
		if l2 == nil {
			break
		}
		l1 = l1.link
	}

	l2 = l1.link
	l1.link = nil
	l1 = csort(l, f)
	l2 = csort(l2, f)

	/* set up lead element */
	if f(l1, l2) < 0 {
		l = l1
		l1 = l1.link
	} else {
		l = l2
		l2 = l2.link
	}

	le := l

	for {
		if l1 == nil {
			for l2 != nil {
				le.link = l2
				le = l2
				l2 = l2.link
			}

			le.link = nil
			break
		}

		if l2 == nil {
			for l1 != nil {
				le.link = l1
				le = l1
				l1 = l1.link
			}

			break
		}

		if f(l1, l2) < 0 {
			le.link = l1
			le = l1
			l1 = l1.link
		} else {
			le.link = l2
			le = l2
			l2 = l2.link
		}
	}

	le.link = nil
	return l
}

var newlabel_swt_label int

func newlabel_swt() *Node {
	newlabel_swt_label++
	namebuf = fmt.Sprintf("%.6d", newlabel_swt_label)
	return newname(Lookup(namebuf))
}

/*
 * build separate list of statements and cases
 * make labels between cases and statements
 * deal with fallthrough, break, unreachable statements
 */
func casebody(sw *Node, typeswvar *Node) {
	if sw.List == nil {
		return
	}

	lno := setlineno(sw)

	cas := (*NodeList)(nil)  // cases
	stat := (*NodeList)(nil) // statements
	def := (*Node)(nil)      // defaults
	br := Nod(OBREAK, nil, nil)

	var c *Node
	var go_ *Node
	var needvar bool
	var lc *NodeList
	var last *Node
	var n *Node
	for l := sw.List; l != nil; l = l.Next {
		n = l.N
		setlineno(n)
		if n.Op != OXCASE {
			Fatal("casebody %v", Oconv(int(n.Op), 0))
		}
		n.Op = OCASE
		needvar = count(n.List) != 1 || n.List.N.Op == OLITERAL

		go_ = Nod(OGOTO, newlabel_swt(), nil)
		if n.List == nil {
			if def != nil {
				Yyerror("more than one default case")
			}

			// reuse original default case
			n.Right = go_

			def = n
		}

		if n.List != nil && n.List.Next == nil {
			// one case - reuse OCASE node.
			c = n.List.N

			n.Left = c
			n.Right = go_
			n.List = nil
			cas = list(cas, n)
		} else {
			// expand multi-valued cases
			for lc = n.List; lc != nil; lc = lc.Next {
				c = lc.N
				cas = list(cas, Nod(OCASE, c, go_))
			}
		}

		stat = list(stat, Nod(OLABEL, go_.Left, nil))
		if typeswvar != nil && needvar && n.Nname != nil {
			l := list1(Nod(ODCL, n.Nname, nil))
			l = list(l, Nod(OAS, n.Nname, typeswvar))
			typechecklist(l, Etop)
			stat = concat(stat, l)
		}

		stat = concat(stat, n.Nbody)

		// botch - shouldn't fall thru declaration
		last = stat.End.N

		if last.Xoffset == n.Xoffset && last.Op == OXFALL {
			if typeswvar != nil {
				setlineno(last)
				Yyerror("cannot fallthrough in type switch")
			}

			if l.Next == nil {
				setlineno(last)
				Yyerror("cannot fallthrough final case in switch")
			}

			last.Op = OFALL
		} else {
			stat = list(stat, br)
		}
	}

	stat = list(stat, br)
	if def != nil {
		cas = list(cas, def)
	}

	sw.List = cas
	sw.Nbody = stat
	lineno = lno
}

func mkcaselist(sw *Node, arg int) *Case {
	var n *Node
	var c1 *Case

	c := (*Case)(nil)
	ord := 0

	for l := sw.List; l != nil; l = l.Next {
		n = l.N
		c1 = new(Case)
		c1.link = c
		c = c1

		ord++
		if int(uint16(ord)) != ord {
			Fatal("too many cases in switch")
		}
		c.ordinal = uint16(ord)
		c.node = n

		if n.Left == nil {
			c.type_ = Tdefault
			continue
		}

		switch arg {
		case Stype:
			c.hash = 0
			if n.Left.Op == OLITERAL {
				c.type_ = Ttypenil
				continue
			}

			if Istype(n.Left.Type, TINTER) {
				c.type_ = Ttypevar
				continue
			}

			c.hash = typehash(n.Left.Type)
			c.type_ = Ttypeconst
			continue

		case Snorm,
			Strue,
			Sfalse:
			c.type_ = Texprvar
			c.hash = typehash(n.Left.Type)
			switch consttype(n.Left) {
			case CTFLT,
				CTINT,
				CTRUNE,
				CTSTR:
				c.type_ = Texprconst
			}

			continue
		}
	}

	if c == nil {
		return nil
	}

	// sort by value and diagnose duplicate cases
	switch arg {
	case Stype:
		c = csort(c, typecmp)
		var c2 *Case
		for c1 := c; c1 != nil; c1 = c1.link {
			for c2 = c1.link; c2 != nil && c2.hash == c1.hash; c2 = c2.link {
				if c1.type_ == Ttypenil || c1.type_ == Tdefault {
					break
				}
				if c2.type_ == Ttypenil || c2.type_ == Tdefault {
					break
				}
				if !Eqtype(c1.node.Left.Type, c2.node.Left.Type) {
					continue
				}
				yyerrorl(int(c2.node.Lineno), "duplicate case %v in type switch\n\tprevious case at %v", Tconv(c2.node.Left.Type, 0), c1.node.Line())
			}
		}

	case Snorm,
		Strue,
		Sfalse:
		c = csort(c, exprcmp)
		for c1 := c; c1.link != nil; c1 = c1.link {
			if exprcmp(c1, c1.link) != 0 {
				continue
			}
			setlineno(c1.link.node)
			Yyerror("duplicate case %v in switch\n\tprevious case at %v", Nconv(c1.node.Left, 0), c1.node.Line())
		}
	}

	// put list back in processing order
	c = csort(c, ordlcmp)

	return c
}

var exprname *Node

func exprbsw(c0 *Case, ncase int, arg int) *Node {
	cas := (*NodeList)(nil)
	if ncase < Ncase {
		var a *Node
		var n *Node
		var lno int
		for i := 0; i < ncase; i++ {
			n = c0.node
			lno = int(setlineno(n))

			if (arg != Strue && arg != Sfalse) || assignop(n.Left.Type, exprname.Type, nil) == OCONVIFACE || assignop(exprname.Type, n.Left.Type, nil) == OCONVIFACE {
				a = Nod(OIF, nil, nil)
				a.Ntest = Nod(OEQ, exprname, n.Left) // if name == val
				typecheck(&a.Ntest, Erv)
				a.Nbody = list1(n.Right) // then goto l
			} else if arg == Strue {
				a = Nod(OIF, nil, nil)
				a.Ntest = n.Left         // if val
				a.Nbody = list1(n.Right) // then goto l // arg == Sfalse
			} else {
				a = Nod(OIF, nil, nil)
				a.Ntest = Nod(ONOT, n.Left, nil) // if !val
				typecheck(&a.Ntest, Erv)
				a.Nbody = list1(n.Right) // then goto l
			}

			cas = list(cas, a)
			c0 = c0.link
			lineno = int32(lno)
		}

		return liststmt(cas)
	}

	// find the middle and recur
	c := c0

	half := ncase >> 1
	for i := 1; i < half; i++ {
		c = c.link
	}
	a := Nod(OIF, nil, nil)
	a.Ntest = Nod(OLE, exprname, c.node.Left)
	typecheck(&a.Ntest, Erv)
	a.Nbody = list1(exprbsw(c0, half, arg))
	a.Nelse = list1(exprbsw(c.link, ncase-half, arg))
	return a
}

/*
 * normal (expression) switch.
 * rebuild case statements into if .. goto
 */
func exprswitch(sw *Node) {
	casebody(sw, nil)

	arg := Snorm
	if Isconst(sw.Ntest, CTBOOL) {
		arg = Strue
		if sw.Ntest.Val.U.Bval == 0 {
			arg = Sfalse
		}
	}

	walkexpr(&sw.Ntest, &sw.Ninit)
	t := sw.Type
	if t == nil {
		return
	}

	/*
	 * convert the switch into OIF statements
	 */
	exprname = nil

	cas := (*NodeList)(nil)
	if arg == Strue || arg == Sfalse {
		exprname = Nodbool(arg == Strue)
	} else if consttype(sw.Ntest) >= 0 {
		// leave constants to enable dead code elimination (issue 9608)
		exprname = sw.Ntest
	} else {
		exprname = temp(sw.Ntest.Type)
		cas = list1(Nod(OAS, exprname, sw.Ntest))
		typechecklist(cas, Etop)
	}

	c0 := mkcaselist(sw, arg)
	var def *Node
	if c0 != nil && c0.type_ == Tdefault {
		def = c0.node.Right
		c0 = c0.link
	} else {
		def = Nod(OBREAK, nil, nil)
	}

	var c *Case
	var a *Node
	var ncase int
	var c1 *Case
loop:
	if c0 == nil {
		cas = list(cas, def)
		sw.Nbody = concat(cas, sw.Nbody)
		sw.List = nil
		walkstmtlist(sw.Nbody)
		return
	}

	// deal with the variables one-at-a-time
	if okforcmp[t.Etype] == 0 || c0.type_ != Texprconst {
		a = exprbsw(c0, 1, arg)
		cas = list(cas, a)
		c0 = c0.link
		goto loop
	}

	// do binary search on run of constants
	ncase = 1

	for c = c0; c.link != nil; c = c.link {
		if c.link.type_ != Texprconst {
			break
		}
		ncase++
	}

	// break the chain at the count
	c1 = c.link

	c.link = nil

	// sort and compile constants
	c0 = csort(c0, exprcmp)

	a = exprbsw(c0, ncase, arg)
	cas = list(cas, a)

	c0 = c1
	goto loop
}

var hashname *Node

var facename *Node

var boolname *Node

func typeone(t *Node) *Node {
	var_ := t.Nname
	init := (*NodeList)(nil)
	if var_ == nil {
		typecheck(&nblank, Erv|Easgn)
		var_ = nblank
	} else {
		init = list1(Nod(ODCL, var_, nil))
	}

	a := Nod(OAS2, nil, nil)
	a.List = list(list1(var_), boolname) // var,bool =
	b := Nod(ODOTTYPE, facename, nil)
	b.Type = t.Left.Type // interface.(type)
	a.Rlist = list1(b)
	typecheck(&a, Etop)
	init = list(init, a)

	b = Nod(OIF, nil, nil)
	b.Ntest = boolname
	b.Nbody = list1(t.Right) // if bool { goto l }
	a = liststmt(list(init, b))
	return a
}

func typebsw(c0 *Case, ncase int) *Node {
	cas := (*NodeList)(nil)

	if ncase < Ncase {
		var n *Node
		var a *Node
		for i := 0; i < ncase; i++ {
			n = c0.node
			if c0.type_ != Ttypeconst {
				Fatal("typebsw")
			}
			a = Nod(OIF, nil, nil)
			a.Ntest = Nod(OEQ, hashname, Nodintconst(int64(c0.hash)))
			typecheck(&a.Ntest, Erv)
			a.Nbody = list1(n.Right)
			cas = list(cas, a)
			c0 = c0.link
		}

		return liststmt(cas)
	}

	// find the middle and recur
	c := c0

	half := ncase >> 1
	for i := 1; i < half; i++ {
		c = c.link
	}
	a := Nod(OIF, nil, nil)
	a.Ntest = Nod(OLE, hashname, Nodintconst(int64(c.hash)))
	typecheck(&a.Ntest, Erv)
	a.Nbody = list1(typebsw(c0, half))
	a.Nelse = list1(typebsw(c.link, ncase-half))
	return a
}

/*
 * convert switch of the form
 *	switch v := i.(type) { case t1: ..; case t2: ..; }
 * into if statements
 */
func typeswitch(sw *Node) {
	if sw.Ntest == nil {
		return
	}
	if sw.Ntest.Right == nil {
		setlineno(sw)
		Yyerror("type switch must have an assignment")
		return
	}

	walkexpr(&sw.Ntest.Right, &sw.Ninit)
	if !Istype(sw.Ntest.Right.Type, TINTER) {
		Yyerror("type switch must be on an interface")
		return
	}

	cas := (*NodeList)(nil)

	/*
	 * predeclare temporary variables
	 * and the boolean var
	 */
	facename = temp(sw.Ntest.Right.Type)

	a := Nod(OAS, facename, sw.Ntest.Right)
	typecheck(&a, Etop)
	cas = list(cas, a)

	casebody(sw, facename)

	boolname = temp(Types[TBOOL])
	typecheck(&boolname, Erv)

	hashname = temp(Types[TUINT32])
	typecheck(&hashname, Erv)

	t := sw.Ntest.Right.Type
	if isnilinter(t) {
		a = syslook("efacethash", 1)
	} else {
		a = syslook("ifacethash", 1)
	}
	argtype(a, t)
	a = Nod(OCALL, a, nil)
	a.List = list1(facename)
	a = Nod(OAS, hashname, a)
	typecheck(&a, Etop)
	cas = list(cas, a)

	c0 := mkcaselist(sw, Stype)
	var def *Node
	if c0 != nil && c0.type_ == Tdefault {
		def = c0.node.Right
		c0 = c0.link
	} else {
		def = Nod(OBREAK, nil, nil)
	}

	/*
	 * insert if statement into each case block
	 */
	var v Val
	var n *Node
	for c := c0; c != nil; c = c.link {
		n = c.node
		switch c.type_ {
		case Ttypenil:
			v.Ctype = CTNIL
			a = Nod(OIF, nil, nil)
			a.Ntest = Nod(OEQ, facename, nodlit(v))
			typecheck(&a.Ntest, Erv)
			a.Nbody = list1(n.Right) // if i==nil { goto l }
			n.Right = a

		case Ttypevar,
			Ttypeconst:
			n.Right = typeone(n)
		}
	}

	/*
	 * generate list of if statements, binary search for constant sequences
	 */
	var ncase int
	var c1 *Case
	var hash *NodeList
	var c *Case
	for c0 != nil {
		if c0.type_ != Ttypeconst {
			n = c0.node
			cas = list(cas, n.Right)
			c0 = c0.link
			continue
		}

		// identify run of constants
		c = c0
		c1 = c

		for c.link != nil && c.link.type_ == Ttypeconst {
			c = c.link
		}
		c0 = c.link
		c.link = nil

		// sort by hash
		c1 = csort(c1, typecmp)

		// for debugging: linear search
		if false {
			for c = c1; c != nil; c = c.link {
				n = c.node
				cas = list(cas, n.Right)
			}

			continue
		}

		// combine adjacent cases with the same hash
		ncase = 0

		for c = c1; c != nil; c = c.link {
			ncase++
			hash = list1(c.node.Right)
			for c.link != nil && c.link.hash == c.hash {
				hash = list(hash, c.link.node.Right)
				c.link = c.link.link
			}

			c.node.Right = liststmt(hash)
		}

		// binary search among cases to narrow by hash
		cas = list(cas, typebsw(c1, ncase))
	}

	if nerrors == 0 {
		cas = list(cas, def)
		sw.Nbody = concat(cas, sw.Nbody)
		sw.List = nil
		walkstmtlist(sw.Nbody)
	}
}

func walkswitch(sw *Node) {
	/*
	 * reorder the body into (OLIST, cases, statements)
	 * cases have OGOTO into statements.
	 * both have inserted OBREAK statements
	 */
	if sw.Ntest == nil {
		sw.Ntest = Nodbool(true)
		typecheck(&sw.Ntest, Erv)
	}

	if sw.Ntest.Op == OTYPESW {
		typeswitch(sw)

		//dump("sw", sw);
		return
	}

	exprswitch(sw)

	// Discard old AST elements after a walk. They can confuse racewealk.
	sw.Ntest = nil

	sw.List = nil
}

/*
 * type check switch statement
 */
func typecheckswitch(n *Node) {
	var top int
	var t *Type

	lno := int(lineno)
	typechecklist(n.Ninit, Etop)
	nilonly := ""

	if n.Ntest != nil && n.Ntest.Op == OTYPESW {
		// type switch
		top = Etype

		typecheck(&n.Ntest.Right, Erv)
		t = n.Ntest.Right.Type
		if t != nil && t.Etype != TINTER {
			Yyerror("cannot type switch on non-interface value %v", Nconv(n.Ntest.Right, obj.FmtLong))
		}
	} else {
		// value switch
		top = Erv

		if n.Ntest != nil {
			typecheck(&n.Ntest, Erv)
			defaultlit(&n.Ntest, nil)
			t = n.Ntest.Type
		} else {
			t = Types[TBOOL]
		}
		if t != nil {
			var badtype *Type
			if okforeq[t.Etype] == 0 {
				Yyerror("cannot switch on %v", Nconv(n.Ntest, obj.FmtLong))
			} else if t.Etype == TARRAY && !Isfixedarray(t) {
				nilonly = "slice"
			} else if t.Etype == TARRAY && Isfixedarray(t) && algtype1(t, nil) == ANOEQ {
				Yyerror("cannot switch on %v", Nconv(n.Ntest, obj.FmtLong))
			} else if t.Etype == TSTRUCT && algtype1(t, &badtype) == ANOEQ {
				Yyerror("cannot switch on %v (struct containing %v cannot be compared)", Nconv(n.Ntest, obj.FmtLong), Tconv(badtype, 0))
			} else if t.Etype == TFUNC {
				nilonly = "func"
			} else if t.Etype == TMAP {
				nilonly = "map"
			}
		}
	}

	n.Type = t

	def := (*Node)(nil)
	var ptr int
	var have *Type
	var nvar *Node
	var ll *NodeList
	var missing *Type
	var ncase *Node
	for l := n.List; l != nil; l = l.Next {
		ncase = l.N
		setlineno(n)
		if ncase.List == nil {
			// default
			if def != nil {
				Yyerror("multiple defaults in switch (first at %v)", def.Line())
			} else {
				def = ncase
			}
		} else {
			for ll = ncase.List; ll != nil; ll = ll.Next {
				setlineno(ll.N)
				typecheck(&ll.N, Erv|Etype)
				if ll.N.Type == nil || t == nil {
					continue
				}
				setlineno(ncase)
				switch top {
				case Erv: // expression switch
					defaultlit(&ll.N, t)

					if ll.N.Op == OTYPE {
						Yyerror("type %v is not an expression", Tconv(ll.N.Type, 0))
					} else if ll.N.Type != nil && assignop(ll.N.Type, t, nil) == 0 && assignop(t, ll.N.Type, nil) == 0 {
						if n.Ntest != nil {
							Yyerror("invalid case %v in switch on %v (mismatched types %v and %v)", Nconv(ll.N, 0), Nconv(n.Ntest, 0), Tconv(ll.N.Type, 0), Tconv(t, 0))
						} else {
							Yyerror("invalid case %v in switch (mismatched types %v and bool)", Nconv(ll.N, 0), Tconv(ll.N.Type, 0))
						}
					} else if nilonly != "" && !Isconst(ll.N, CTNIL) {
						Yyerror("invalid case %v in switch (can only compare %s %v to nil)", Nconv(ll.N, 0), nilonly, Nconv(n.Ntest, 0))
					}

				case Etype: // type switch
					if ll.N.Op == OLITERAL && Istype(ll.N.Type, TNIL) {
					} else if ll.N.Op != OTYPE && ll.N.Type != nil { // should this be ||?
						Yyerror("%v is not a type", Nconv(ll.N, obj.FmtLong))

						// reset to original type
						ll.N = n.Ntest.Right
					} else if ll.N.Type.Etype != TINTER && t.Etype == TINTER && !implements(ll.N.Type, t, &missing, &have, &ptr) {
						if have != nil && missing.Broke == 0 && have.Broke == 0 {
							Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (wrong type for %v method)\n\thave %v%v\n\twant %v%v", Nconv(n.Ntest.Right, obj.FmtLong), Tconv(ll.N.Type, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort))
						} else if missing.Broke == 0 {
							Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (missing %v method)", Nconv(n.Ntest.Right, obj.FmtLong), Tconv(ll.N.Type, 0), Sconv(missing.Sym, 0))
						}
					}
				}
			}
		}

		if top == Etype && n.Type != nil {
			ll = ncase.List
			nvar = ncase.Nname
			if nvar != nil {
				if ll != nil && ll.Next == nil && ll.N.Type != nil && !Istype(ll.N.Type, TNIL) {
					// single entry type switch
					nvar.Ntype = typenod(ll.N.Type)
				} else {
					// multiple entry type switch or default
					nvar.Ntype = typenod(n.Type)
				}

				typecheck(&nvar, Erv|Easgn)
				ncase.Nname = nvar
			}
		}

		typechecklist(ncase.Nbody, Etop)
	}

	lineno = int32(lno)
}