operand.go

Documentation: go/types

		 1  // Copyright 2012 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // This file defines operands and associated operations.
		 6  
		 7  package types
		 8  
		 9  import (
		10  	"bytes"
		11  	"fmt"
		12  	"go/ast"
		13  	"go/constant"
		14  	"go/token"
		15  )
		16  
		17  // An operandMode specifies the (addressing) mode of an operand.
		18  type operandMode byte
		19  
		20  const (
		21  	invalid	 operandMode = iota // operand is invalid
		22  	novalue											// operand represents no value (result of a function call w/o result)
		23  	builtin											// operand is a built-in function
		24  	typexpr											// operand is a type
		25  	constant_										// operand is a constant; the operand's typ is a Basic type
		26  	variable										 // operand is an addressable variable
		27  	mapindex										 // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment)
		28  	value												// operand is a computed value
		29  	commaok											// like value, but operand may be used in a comma,ok expression
		30  	commaerr										 // like commaok, but second value is error, not boolean
		31  	cgofunc											// operand is a cgo function
		32  )
		33  
		34  var operandModeString = [...]string{
		35  	invalid:	 "invalid operand",
		36  	novalue:	 "no value",
		37  	builtin:	 "built-in",
		38  	typexpr:	 "type",
		39  	constant_: "constant",
		40  	variable:	"variable",
		41  	mapindex:	"map index expression",
		42  	value:		 "value",
		43  	commaok:	 "comma, ok expression",
		44  	commaerr:	"comma, error expression",
		45  	cgofunc:	 "cgo function",
		46  }
		47  
		48  // An operand represents an intermediate value during type checking.
		49  // Operands have an (addressing) mode, the expression evaluating to
		50  // the operand, the operand's type, a value for constants, and an id
		51  // for built-in functions.
		52  // The zero value of operand is a ready to use invalid operand.
		53  //
		54  type operand struct {
		55  	mode operandMode
		56  	expr ast.Expr
		57  	typ	Type
		58  	val	constant.Value
		59  	id	 builtinId
		60  }
		61  
		62  // Pos returns the position of the expression corresponding to x.
		63  // If x is invalid the position is token.NoPos.
		64  //
		65  func (x *operand) Pos() token.Pos {
		66  	// x.expr may not be set if x is invalid
		67  	if x.expr == nil {
		68  		return token.NoPos
		69  	}
		70  	return x.expr.Pos()
		71  }
		72  
		73  // Operand string formats
		74  // (not all "untyped" cases can appear due to the type system,
		75  // but they fall out naturally here)
		76  //
		77  // mode			 format
		78  //
		79  // invalid		<expr> (							 <mode>										)
		80  // novalue		<expr> (							 <mode>										)
		81  // builtin		<expr> (							 <mode>										)
		82  // typexpr		<expr> (							 <mode>										)
		83  //
		84  // constant	 <expr> (<untyped kind> <mode>										)
		85  // constant	 <expr> (							 <mode>			 of type <typ>)
		86  // constant	 <expr> (<untyped kind> <mode> <val>							)
		87  // constant	 <expr> (							 <mode> <val> of type <typ>)
		88  //
		89  // variable	 <expr> (<untyped kind> <mode>										)
		90  // variable	 <expr> (							 <mode>			 of type <typ>)
		91  //
		92  // mapindex	 <expr> (<untyped kind> <mode>										)
		93  // mapindex	 <expr> (							 <mode>			 of type <typ>)
		94  //
		95  // value			<expr> (<untyped kind> <mode>										)
		96  // value			<expr> (							 <mode>			 of type <typ>)
		97  //
		98  // commaok		<expr> (<untyped kind> <mode>										)
		99  // commaok		<expr> (							 <mode>			 of type <typ>)
	 100  //
	 101  // commaerr	 <expr> (<untyped kind> <mode>										)
	 102  // commaerr	 <expr> (							 <mode>			 of type <typ>)
	 103  //
	 104  // cgofunc		<expr> (<untyped kind> <mode>										)
	 105  // cgofunc		<expr> (							 <mode>			 of type <typ>)
	 106  //
	 107  func operandString(x *operand, qf Qualifier) string {
	 108  	var buf bytes.Buffer
	 109  
	 110  	var expr string
	 111  	if x.expr != nil {
	 112  		expr = ExprString(x.expr)
	 113  	} else {
	 114  		switch x.mode {
	 115  		case builtin:
	 116  			expr = predeclaredFuncs[x.id].name
	 117  		case typexpr:
	 118  			expr = TypeString(x.typ, qf)
	 119  		case constant_:
	 120  			expr = x.val.String()
	 121  		}
	 122  	}
	 123  
	 124  	// <expr> (
	 125  	if expr != "" {
	 126  		buf.WriteString(expr)
	 127  		buf.WriteString(" (")
	 128  	}
	 129  
	 130  	// <untyped kind>
	 131  	hasType := false
	 132  	switch x.mode {
	 133  	case invalid, novalue, builtin, typexpr:
	 134  		// no type
	 135  	default:
	 136  		// should have a type, but be cautious (don't crash during printing)
	 137  		if x.typ != nil {
	 138  			if isUntyped(x.typ) {
	 139  				buf.WriteString(x.typ.(*Basic).name)
	 140  				buf.WriteByte(' ')
	 141  				break
	 142  			}
	 143  			hasType = true
	 144  		}
	 145  	}
	 146  
	 147  	// <mode>
	 148  	buf.WriteString(operandModeString[x.mode])
	 149  
	 150  	// <val>
	 151  	if x.mode == constant_ {
	 152  		if s := x.val.String(); s != expr {
	 153  			buf.WriteByte(' ')
	 154  			buf.WriteString(s)
	 155  		}
	 156  	}
	 157  
	 158  	// <typ>
	 159  	if hasType {
	 160  		if x.typ != Typ[Invalid] {
	 161  			var intro string
	 162  			switch {
	 163  			case isGeneric(x.typ):
	 164  				intro = " of generic type "
	 165  			case asTypeParam(x.typ) != nil:
	 166  				intro = " of type parameter type "
	 167  			default:
	 168  				intro = " of type "
	 169  			}
	 170  			buf.WriteString(intro)
	 171  			WriteType(&buf, x.typ, qf)
	 172  		} else {
	 173  			buf.WriteString(" with invalid type")
	 174  		}
	 175  	}
	 176  
	 177  	// )
	 178  	if expr != "" {
	 179  		buf.WriteByte(')')
	 180  	}
	 181  
	 182  	return buf.String()
	 183  }
	 184  
	 185  func (x *operand) String() string {
	 186  	return operandString(x, nil)
	 187  }
	 188  
	 189  // setConst sets x to the untyped constant for literal lit.
	 190  func (x *operand) setConst(tok token.Token, lit string) {
	 191  	var kind BasicKind
	 192  	switch tok {
	 193  	case token.INT:
	 194  		kind = UntypedInt
	 195  	case token.FLOAT:
	 196  		kind = UntypedFloat
	 197  	case token.IMAG:
	 198  		kind = UntypedComplex
	 199  	case token.CHAR:
	 200  		kind = UntypedRune
	 201  	case token.STRING:
	 202  		kind = UntypedString
	 203  	default:
	 204  		unreachable()
	 205  	}
	 206  
	 207  	val := constant.MakeFromLiteral(lit, tok, 0)
	 208  	if val.Kind() == constant.Unknown {
	 209  		x.mode = invalid
	 210  		x.typ = Typ[Invalid]
	 211  		return
	 212  	}
	 213  	x.mode = constant_
	 214  	x.typ = Typ[kind]
	 215  	x.val = val
	 216  }
	 217  
	 218  // isNil reports whether x is the nil value.
	 219  func (x *operand) isNil() bool {
	 220  	return x.mode == value && x.typ == Typ[UntypedNil]
	 221  }
	 222  
	 223  // assignableTo reports whether x is assignable to a variable of type T. If the
	 224  // result is false and a non-nil reason is provided, it may be set to a more
	 225  // detailed explanation of the failure (result != ""). The returned error code
	 226  // is only valid if the (first) result is false. The check parameter may be nil
	 227  // if assignableTo is invoked through an exported API call, i.e., when all
	 228  // methods have been type-checked.
	 229  func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, errorCode) {
	 230  	if x.mode == invalid || T == Typ[Invalid] {
	 231  		return true, 0 // avoid spurious errors
	 232  	}
	 233  
	 234  	V := x.typ
	 235  
	 236  	// x's type is identical to T
	 237  	if check.identical(V, T) {
	 238  		return true, 0
	 239  	}
	 240  
	 241  	Vu := optype(V)
	 242  	Tu := optype(T)
	 243  
	 244  	// x is an untyped value representable by a value of type T.
	 245  	if isUntyped(Vu) {
	 246  		if t, ok := Tu.(*_Sum); ok {
	 247  			return t.is(func(t Type) bool {
	 248  				// TODO(gri) this could probably be more efficient
	 249  				ok, _ := x.assignableTo(check, t, reason)
	 250  				return ok
	 251  			}), _IncompatibleAssign
	 252  		}
	 253  		newType, _, _ := check.implicitTypeAndValue(x, Tu)
	 254  		return newType != nil, _IncompatibleAssign
	 255  	}
	 256  	// Vu is typed
	 257  
	 258  	// x's type V and T have identical underlying types
	 259  	// and at least one of V or T is not a named type
	 260  	if check.identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
	 261  		return true, 0
	 262  	}
	 263  
	 264  	// T is an interface type and x implements T
	 265  	if Ti, ok := Tu.(*Interface); ok {
	 266  		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ {
	 267  			if reason != nil {
	 268  				if wrongType != nil {
	 269  					if check.identical(m.typ, wrongType.typ) {
	 270  						*reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name)
	 271  					} else {
	 272  						*reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ)
	 273  					}
	 274  
	 275  				} else {
	 276  					*reason = "missing method " + m.Name()
	 277  				}
	 278  			}
	 279  			return false, _InvalidIfaceAssign
	 280  		}
	 281  		return true, 0
	 282  	}
	 283  
	 284  	// x is a bidirectional channel value, T is a channel
	 285  	// type, x's type V and T have identical element types,
	 286  	// and at least one of V or T is not a named type
	 287  	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
	 288  		if Tc, ok := Tu.(*Chan); ok && check.identical(Vc.elem, Tc.elem) {
	 289  			return !isNamed(V) || !isNamed(T), _InvalidChanAssign
	 290  		}
	 291  	}
	 292  
	 293  	return false, _IncompatibleAssign
	 294  }
	 295
View as plain text