var go/types.Typ

161 uses

	go/types (current package)
		alias.go#L128: 	if t != Typ[Invalid] {
		alias.go#L181: 	if actual == Typ[Invalid] {
		api.go#L420: 	return tv.mode == value && tv.Type == Typ[UntypedNil]
		assignments.go#L62: 				if T == nil && x.typ == Typ[UntypedNil] {
		assignments.go#L124: 			lhs.typ = Typ[Invalid]
		assignments.go#L133: 			lhs.typ = Typ[Invalid]
		assignments.go#L159: 			lhs.typ = Typ[Invalid]
		assignments.go#L170: 			if typ == Typ[UntypedNil] {
		assignments.go#L172: 				lhs.typ = Typ[Invalid]
		assignments.go#L223: 		return Typ[Invalid]
		assignments.go#L230: 		return Typ[Invalid]
		assignments.go#L239: 				return Typ[Invalid]
		assignments.go#L243: 		return Typ[Invalid]
		assignments.go#L433: 				v.typ = Typ[Invalid]
		assignments.go#L465: 			v.typ = Typ[Invalid]
		builtins.go#L223: 			check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ))
		builtins.go#L227: 		x.typ = Typ[Int]
		builtins.go#L304: 						x.typ = Typ[UntypedFloat]
		builtins.go#L310: 				check.convertUntyped(x, Typ[Float64])
		builtins.go#L311: 				check.convertUntyped(y, Typ[Float64])
		builtins.go#L333: 					return Typ[Complex64]
		builtins.go#L335: 					return Typ[Complex128]
		builtins.go#L337: 					return Typ[UntypedComplex]
		builtins.go#L383: 			check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
		builtins.go#L386: 		x.typ = Typ[Int]
		builtins.go#L431: 					x.typ = Typ[UntypedComplex]
		builtins.go#L438: 				check.convertUntyped(x, Typ[Complex128])
		builtins.go#L453: 					return Typ[Float32]
		builtins.go#L455: 					return Typ[Float64]
		builtins.go#L457: 					return Typ[UntypedFloat]
		builtins.go#L672: 		check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
		builtins.go#L683: 		x.typ = Typ[UnsafePointer]
		builtins.go#L698: 				check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], x.typ))
		builtins.go#L705: 		x.typ = Typ[Uintptr]
		builtins.go#L762: 				check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], obj.Type()))
		builtins.go#L774: 		x.typ = Typ[Uintptr]
		builtins.go#L786: 				check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], x.typ))
		builtins.go#L798: 		x.typ = Typ[Uintptr]
		builtins.go#L852: 		x.typ = Typ[String]
		builtins.go#L861: 		check.assignment(x, Typ[String], "argument to unsafe.StringData")
		builtins.go#L869: 			check.recordBuiltinType(call.Fun, makeSig(x.typ, Typ[String]))
		check.go#L228: 	alias.typ = Typ[Invalid]
		conversions.go#L112: 		if isTypes2 && x.typ == Typ[UntypedNil] {
		decl.go#L129: 				obj.typ = Typ[Invalid]
		decl.go#L134: 				obj.typ = Typ[Invalid]
		decl.go#L144: 				obj.typ = Typ[Invalid]
		decl.go#L317: 			check.validAlias(tname, Typ[Invalid])
		decl.go#L455: 			obj.typ = Typ[Invalid]
		decl.go#L498: 			obj.typ = Typ[Invalid]
		decl.go#L582: 			alias := check.newAlias(obj, Typ[Invalid])
		decl.go#L642: 		named.underlying = Typ[Invalid]
		decl.go#L652: 		named.underlying = Typ[Invalid]
		decl.go#L699: 				bound = Typ[Invalid]
		decl.go#L702: 			bound = Typ[Invalid]
		decl.go#L742: 	tpar := check.newTypeParam(tname, Typ[Invalid]) // assigns type to tname as a side-effect
		expr.go#L406: 			return Typ[UntypedNil], nil, 0
		expr.go#L423: 				return Typ[UntypedNil], nil, 0
		expr.go#L432: 			return Typ[UntypedNil], nil, 0
		expr.go#L444: 		return Typ[UntypedNil], nil, 0
		expr.go#L546: 	x.typ = Typ[UntypedBool]
		expr.go#L627: 			check.representable(y, Typ[Uint])
		expr.go#L644: 			check.convertUntyped(y, Typ[Uint])
		expr.go#L663: 					x.typ = Typ[UntypedInt]
		expr.go#L680: 				x.typ = Typ[UntypedInt]
		expr.go#L988: 		x.typ = Typ[Invalid]
		expr.go#L999: 	x.typ = Typ[Invalid]
		expr.go#L1261: 		x2 := &operand{mode: value, expr: e, typ: Typ[UntypedBool]}
		index.go#L204: 		x.typ = Typ[Invalid]
		index.go#L244: 				x.typ = Typ[String]
		index.go#L350: 	typ = Typ[Invalid]
		index.go#L384: 	check.convertUntyped(x, Typ[Int])
		index.go#L403: 		if !representableConst(x.val, check, Typ[Int], &x.val) {
		instantiate.go#L147: 			return Typ[Invalid]
		instantiate.go#L161: 			return Typ[Invalid]
		literals.go#L145: 		typ = Typ[Invalid]
		lookup.go#L584: 			return Typ[Invalid], true
		named.go#L578: 			u = Typ[Invalid]
		named.go#L584: 			u = Typ[Invalid]
		named.go#L659: 		return Typ[Invalid]
		object.go#L253: 	return &PkgName{object{nil, pos, pkg, name, Typ[Invalid], 0, black, nopos}, imported}
		object.go#L489: 	return &Label{object{pos: pos, pkg: pkg, name: name, typ: Typ[Invalid], color_: black}, false}
		object.go#L500: 	return &Builtin{object{name: predeclaredFuncs[id].name, typ: Typ[Invalid], color_: black}, id}
		operand.go#L118: 			case nil, Typ[Invalid]:
		operand.go#L120: 			case Typ[UntypedNil]:
		operand.go#L127: 		if x.mode == value && x.typ == Typ[UntypedNil] {
		operand.go#L289: 		x.typ = Typ[Invalid]
		operand.go#L293: 	x.typ = Typ[kind]
		operand.go#L302: 		return x.mode == value && x.typ == Typ[UntypedNil]
		predicates.go#L18: func isValid(t Type) bool { return Unalias(t) != Typ[Invalid] }
		predicates.go#L531: 			return Typ[Bool]
		predicates.go#L533: 			return Typ[Int]
		predicates.go#L537: 			return Typ[Float64]
		predicates.go#L539: 			return Typ[Complex128]
		predicates.go#L541: 			return Typ[String]
		recording.go#L25: 		typ = Typ[Invalid]
		signature.go#L172: 	var recvType Type = Typ[Invalid]
		signature.go#L190: 				recvType = Typ[Invalid] // avoid follow-on errors by Checker.validRecv
		stmt.go#L345: 		T = Typ[Invalid]
		stmt.go#L398: 		T = Typ[Invalid]
		stmt.go#L657: 			x.typ = Typ[Bool]
		stmt.go#L955: 			if typ == nil || typ == Typ[Invalid] {
		stmt.go#L957: 				obj.typ = Typ[Invalid]
		stmt.go#L993: 			if typ == nil || typ == Typ[Invalid] {
		stmt.go#L1034: 		return Typ[Invalid], Typ[Invalid], cause, false
		stmt.go#L1043: 			return Typ[Int], universeRune, "", true // use 'rune' name
		stmt.go#L1052: 		return Typ[Int], typ.elem, "", true
		stmt.go#L1054: 		return Typ[Int], typ.elem, "", true
		struct.go#L108: 		typ = Typ[Invalid]
		subst.go#L112: 			return Typ[Invalid] // error reported elsewhere
		subst.go#L254: 			return Typ[Invalid] // error reported elsewhere
		subst.go#L284: 		return Typ[Invalid]
		typexpr.go#L197: 		typ = Typ[Invalid]
		typexpr.go#L217: 		typ = Typ[Invalid]
		typexpr.go#L338: 		typ.base = Typ[Invalid] // avoid nil base in invalid recursive type declaration
		typexpr.go#L346: 			return Typ[Invalid]
		typexpr.go#L413: 	typ := Typ[Invalid]
		typexpr.go#L424: 			assert(t == Typ[Invalid])
		typexpr.go#L465: 		return Typ[Invalid]
		typexpr.go#L475: 		return Typ[Invalid]
		typexpr.go#L536: 			if representableConst(val, check, Typ[Int], nil) {
		under.go#L105: 		return Typ[String]
		union.go#L72: 				u = Typ[Invalid]
		union.go#L158: 		typ = Typ[Invalid]
		universe.go#L42: var Typ = []*Basic{
		universe.go#L79: 	for _, t := range Typ {
		universe.go#L126: 		res := NewVar(nopos, nil, "", Typ[String])
		universe.go#L164: 		def(NewConst(nopos, nil, c.name, Typ[c.kind], c.val))
		universe.go#L169: 	def(&Nil{object{name: "nil", typ: Typ[UntypedNil], color_: black}})
		validtype.go#L131: 				t.underlying = Typ[Invalid]
		validtype.go#L132: 				t.Origin().underlying = Typ[Invalid]

	golang.org/x/tools/internal/gcimporter
		iexport.go#L723: 			if sig.Recv().Type() != types.Typ[types.Invalid] {
		predeclared.go#L34: 		types.Typ[types.Bool],
		predeclared.go#L35: 		types.Typ[types.Int],
		predeclared.go#L36: 		types.Typ[types.Int8],
		predeclared.go#L37: 		types.Typ[types.Int16],
		predeclared.go#L38: 		types.Typ[types.Int32],
		predeclared.go#L39: 		types.Typ[types.Int64],
		predeclared.go#L40: 		types.Typ[types.Uint],
		predeclared.go#L41: 		types.Typ[types.Uint8],
		predeclared.go#L42: 		types.Typ[types.Uint16],
		predeclared.go#L43: 		types.Typ[types.Uint32],
		predeclared.go#L44: 		types.Typ[types.Uint64],
		predeclared.go#L45: 		types.Typ[types.Uintptr],
		predeclared.go#L46: 		types.Typ[types.Float32],
		predeclared.go#L47: 		types.Typ[types.Float64],
		predeclared.go#L48: 		types.Typ[types.Complex64],
		predeclared.go#L49: 		types.Typ[types.Complex128],
		predeclared.go#L50: 		types.Typ[types.String],
		predeclared.go#L60: 		types.Typ[types.UntypedBool],
		predeclared.go#L61: 		types.Typ[types.UntypedInt],
		predeclared.go#L62: 		types.Typ[types.UntypedRune],
		predeclared.go#L63: 		types.Typ[types.UntypedFloat],
		predeclared.go#L64: 		types.Typ[types.UntypedComplex],
		predeclared.go#L65: 		types.Typ[types.UntypedString],
		predeclared.go#L66: 		types.Typ[types.UntypedNil],
		predeclared.go#L69: 		types.Typ[types.UnsafePointer],
		predeclared.go#L72: 		types.Typ[types.Invalid], // only appears in packages with errors
		ureader_yes.go#L346: 		return types.Typ[r.Len()]

	golang.org/x/tools/internal/typeparams
		normalize.go#L192: 				if t.Type() == types.Typ[types.Invalid] {
		normalize.go#L207: 		if u != types.Typ[types.Invalid] {