Файловый менеджер - Редактировать - /var/www/html/types2.zip
Ðазад
PK ! ���� � importer_test.gonu �[��� // Copyright 2020 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. // This file implements the (temporary) plumbing to get importing to work. package types2_test import ( gcimporter "cmd/compile/internal/importer" "cmd/compile/internal/types2" "io" ) func defaultImporter() types2.Importer { return &gcimports{ packages: make(map[string]*types2.Package), } } type gcimports struct { packages map[string]*types2.Package lookup func(path string) (io.ReadCloser, error) } func (m *gcimports) Import(path string) (*types2.Package, error) { return m.ImportFrom(path, "" /* no vendoring */, 0) } func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*types2.Package, error) { if mode != 0 { panic("mode must be 0") } return gcimporter.Import(m.packages, path, srcDir, m.lookup) } PK ! "�+T� � expr.gonu �[��� // Copyright 2012 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. // This file implements typechecking of expressions. package types2 import ( "cmd/compile/internal/syntax" "fmt" "go/constant" "go/token" . "internal/types/errors" ) /* Basic algorithm: Expressions are checked recursively, top down. Expression checker functions are generally of the form: func f(x *operand, e *syntax.Expr, ...) where e is the expression to be checked, and x is the result of the check. The check performed by f may fail in which case x.mode == invalid, and related error messages will have been issued by f. If a hint argument is present, it is the composite literal element type of an outer composite literal; it is used to type-check composite literal elements that have no explicit type specification in the source (e.g.: []T{{...}, {...}}, the hint is the type T in this case). All expressions are checked via rawExpr, which dispatches according to expression kind. Upon returning, rawExpr is recording the types and constant values for all expressions that have an untyped type (those types may change on the way up in the expression tree). Usually these are constants, but the results of comparisons or non-constant shifts of untyped constants may also be untyped, but not constant. Untyped expressions may eventually become fully typed (i.e., not untyped), typically when the value is assigned to a variable, or is used otherwise. The updateExprType method is used to record this final type and update the recorded types: the type-checked expression tree is again traversed down, and the new type is propagated as needed. Untyped constant expression values that become fully typed must now be representable by the full type (constant sub-expression trees are left alone except for their roots). This mechanism ensures that a client sees the actual (run-time) type an untyped value would have. It also permits type-checking of lhs shift operands "as if the shift were not present": when updateExprType visits an untyped lhs shift operand and assigns it it's final type, that type must be an integer type, and a constant lhs must be representable as an integer. When an expression gets its final type, either on the way out from rawExpr, on the way down in updateExprType, or at the end of the type checker run, the type (and constant value, if any) is recorded via Info.Types, if present. */ type opPredicates map[syntax.Operator]func(Type) bool var unaryOpPredicates opPredicates func init() { // Setting unaryOpPredicates in init avoids declaration cycles. unaryOpPredicates = opPredicates{ syntax.Add: allNumeric, syntax.Sub: allNumeric, syntax.Xor: allInteger, syntax.Not: allBoolean, } } func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool { if pred := m[op]; pred != nil { if !pred(x.typ) { check.errorf(x, UndefinedOp, invalidOp+"operator %s not defined on %s", op, x) return false } } else { check.errorf(x, InvalidSyntaxTree, "unknown operator %s", op) return false } return true } // opPos returns the position of the operator if x is an operation; // otherwise it returns the start position of x. func opPos(x syntax.Expr) syntax.Pos { switch op := x.(type) { case nil: return nopos // don't crash case *syntax.Operation: return op.Pos() default: return syntax.StartPos(x) } } // opName returns the name of the operation if x is an operation // that might overflow; otherwise it returns the empty string. func opName(x syntax.Expr) string { if e, _ := x.(*syntax.Operation); e != nil { op := int(e.Op) if e.Y == nil { if op < len(op2str1) { return op2str1[op] } } else { if op < len(op2str2) { return op2str2[op] } } } return "" } var op2str1 = [...]string{ syntax.Xor: "bitwise complement", } // This is only used for operations that may cause overflow. var op2str2 = [...]string{ syntax.Add: "addition", syntax.Sub: "subtraction", syntax.Xor: "bitwise XOR", syntax.Mul: "multiplication", syntax.Shl: "shift", } // If typ is a type parameter, underIs returns the result of typ.underIs(f). // Otherwise, underIs returns the result of f(under(typ)). func underIs(typ Type, f func(Type) bool) bool { if tpar, _ := typ.(*TypeParam); tpar != nil { return tpar.underIs(f) } return f(under(typ)) } func (check *Checker) unary(x *operand, e *syntax.Operation) { check.expr(nil, x, e.X) if x.mode == invalid { return } op := e.Op switch op { case syntax.And: // spec: "As an exception to the addressability // requirement x may also be a composite literal." if _, ok := syntax.Unparen(e.X).(*syntax.CompositeLit); !ok && x.mode != variable { check.errorf(x, UnaddressableOperand, invalidOp+"cannot take address of %s", x) x.mode = invalid return } x.mode = value x.typ = &Pointer{base: x.typ} return case syntax.Recv: u := coreType(x.typ) if u == nil { check.errorf(x, InvalidReceive, invalidOp+"cannot receive from %s (no core type)", x) x.mode = invalid return } ch, _ := u.(*Chan) if ch == nil { check.errorf(x, InvalidReceive, invalidOp+"cannot receive from non-channel %s", x) x.mode = invalid return } if ch.dir == SendOnly { check.errorf(x, InvalidReceive, invalidOp+"cannot receive from send-only channel %s", x) x.mode = invalid return } x.mode = commaok x.typ = ch.elem check.hasCallOrRecv = true return case syntax.Tilde: // Provide a better error position and message than what check.op below would do. if !allInteger(x.typ) { check.error(e, UndefinedOp, "cannot use ~ outside of interface or type constraint") x.mode = invalid return } check.error(e, UndefinedOp, "cannot use ~ outside of interface or type constraint (use ^ for bitwise complement)") op = syntax.Xor } if !check.op(unaryOpPredicates, x, op) { x.mode = invalid return } if x.mode == constant_ { if x.val.Kind() == constant.Unknown { // nothing to do (and don't cause an error below in the overflow check) return } var prec uint if isUnsigned(x.typ) { prec = uint(check.conf.sizeof(x.typ) * 8) } x.val = constant.UnaryOp(op2tok[op], x.val, prec) x.expr = e check.overflow(x, opPos(x.expr)) return } x.mode = value // x.typ remains unchanged } func isShift(op syntax.Operator) bool { return op == syntax.Shl || op == syntax.Shr } func isComparison(op syntax.Operator) bool { // Note: tokens are not ordered well to make this much easier switch op { case syntax.Eql, syntax.Neq, syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq: return true } return false } // updateExprType updates the type of x to typ and invokes itself // recursively for the operands of x, depending on expression kind. // If typ is still an untyped and not the final type, updateExprType // only updates the recorded untyped type for x and possibly its // operands. Otherwise (i.e., typ is not an untyped type anymore, // or it is the final type for x), the type and value are recorded. // Also, if x is a constant, it must be representable as a value of typ, // and if x is the (formerly untyped) lhs operand of a non-constant // shift, it must be an integer value. func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { check.updateExprType0(nil, x, typ, final) } func (check *Checker) updateExprType0(parent, x syntax.Expr, typ Type, final bool) { old, found := check.untyped[x] if !found { return // nothing to do } // update operands of x if necessary switch x := x.(type) { case *syntax.BadExpr, *syntax.FuncLit, *syntax.CompositeLit, *syntax.IndexExpr, *syntax.SliceExpr, *syntax.AssertExpr, *syntax.ListExpr, //*syntax.StarExpr, *syntax.KeyValueExpr, *syntax.ArrayType, *syntax.StructType, *syntax.FuncType, *syntax.InterfaceType, *syntax.MapType, *syntax.ChanType: // These expression are never untyped - nothing to do. // The respective sub-expressions got their final types // upon assignment or use. if debug { check.dump("%v: found old type(%s): %s (new: %s)", atPos(x), x, old.typ, typ) unreachable() } return case *syntax.CallExpr: // Resulting in an untyped constant (e.g., built-in complex). // The respective calls take care of calling updateExprType // for the arguments if necessary. case *syntax.Name, *syntax.BasicLit, *syntax.SelectorExpr: // An identifier denoting a constant, a constant literal, // or a qualified identifier (imported untyped constant). // No operands to take care of. case *syntax.ParenExpr: check.updateExprType0(x, x.X, typ, final) // case *syntax.UnaryExpr: // // If x is a constant, the operands were constants. // // The operands don't need to be updated since they // // never get "materialized" into a typed value. If // // left in the untyped map, they will be processed // // at the end of the type check. // if old.val != nil { // break // } // check.updateExprType0(x, x.X, typ, final) case *syntax.Operation: if x.Y == nil { // unary expression if x.Op == syntax.Mul { // see commented out code for StarExpr above // TODO(gri) needs cleanup if debug { panic("unimplemented") } return } // If x is a constant, the operands were constants. // The operands don't need to be updated since they // never get "materialized" into a typed value. If // left in the untyped map, they will be processed // at the end of the type check. if old.val != nil { break } check.updateExprType0(x, x.X, typ, final) break } // binary expression if old.val != nil { break // see comment for unary expressions } if isComparison(x.Op) { // The result type is independent of operand types // and the operand types must have final types. } else if isShift(x.Op) { // The result type depends only on lhs operand. // The rhs type was updated when checking the shift. check.updateExprType0(x, x.X, typ, final) } else { // The operand types match the result type. check.updateExprType0(x, x.X, typ, final) check.updateExprType0(x, x.Y, typ, final) } default: unreachable() } // If the new type is not final and still untyped, just // update the recorded type. if !final && isUntyped(typ) { old.typ = under(typ).(*Basic) check.untyped[x] = old return } // Otherwise we have the final (typed or untyped type). // Remove it from the map of yet untyped expressions. delete(check.untyped, x) if old.isLhs { // If x is the lhs of a shift, its final type must be integer. // We already know from the shift check that it is representable // as an integer if it is a constant. if !allInteger(typ) { check.errorf(x, InvalidShiftOperand, invalidOp+"shifted operand %s (type %s) must be integer", x, typ) return } // Even if we have an integer, if the value is a constant we // still must check that it is representable as the specific // int type requested (was go.dev/issue/22969). Fall through here. } if old.val != nil { // If x is a constant, it must be representable as a value of typ. c := operand{old.mode, x, old.typ, old.val, 0} check.convertUntyped(&c, typ) if c.mode == invalid { return } } // Everything's fine, record final type and value for x. check.recordTypeAndValue(x, old.mode, typ, old.val) } // updateExprVal updates the value of x to val. func (check *Checker) updateExprVal(x syntax.Expr, val constant.Value) { if info, ok := check.untyped[x]; ok { info.val = val check.untyped[x] = info } } // implicitTypeAndValue returns the implicit type of x when used in a context // where the target type is expected. If no such implicit conversion is // possible, it returns a nil Type and non-zero error code. // // If x is a constant operand, the returned constant.Value will be the // representation of x in this context. func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, Code) { if x.mode == invalid || isTyped(x.typ) || !isValid(target) { return x.typ, nil, 0 } // x is untyped if isUntyped(target) { // both x and target are untyped if m := maxType(x.typ, target); m != nil { return m, nil, 0 } return nil, nil, InvalidUntypedConversion } if x.isNil() { assert(isUntyped(x.typ)) if hasNil(target) { return target, nil, 0 } return nil, nil, InvalidUntypedConversion } switch u := under(target).(type) { case *Basic: if x.mode == constant_ { v, code := check.representation(x, u) if code != 0 { return nil, nil, code } return target, v, code } // Non-constant untyped values may appear as the // result of comparisons (untyped bool), intermediate // (delayed-checked) rhs operands of shifts, and as // the value nil. switch x.typ.(*Basic).kind { case UntypedBool: if !isBoolean(target) { return nil, nil, InvalidUntypedConversion } case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex: if !isNumeric(target) { return nil, nil, InvalidUntypedConversion } case UntypedString: // Non-constant untyped string values are not permitted by the spec and // should not occur during normal typechecking passes, but this path is // reachable via the AssignableTo API. if !isString(target) { return nil, nil, InvalidUntypedConversion } default: return nil, nil, InvalidUntypedConversion } case *Interface: if isTypeParam(target) { if !u.typeSet().underIs(func(u Type) bool { if u == nil { return false } t, _, _ := check.implicitTypeAndValue(x, u) return t != nil }) { return nil, nil, InvalidUntypedConversion } break } // Update operand types to the default type rather than the target // (interface) type: values must have concrete dynamic types. // Untyped nil was handled upfront. if !u.Empty() { return nil, nil, InvalidUntypedConversion // cannot assign untyped values to non-empty interfaces } return Default(x.typ), nil, 0 // default type for nil is nil default: return nil, nil, InvalidUntypedConversion } return target, nil, 0 } // If switchCase is true, the operator op is ignored. func (check *Checker) comparison(x, y *operand, op syntax.Operator, switchCase bool) { // Avoid spurious errors if any of the operands has an invalid type (go.dev/issue/54405). if !isValid(x.typ) || !isValid(y.typ) { x.mode = invalid return } if switchCase { op = syntax.Eql } errOp := x // operand for which error is reported, if any cause := "" // specific error cause, if any // spec: "In any comparison, the first operand must be assignable // to the type of the second operand, or vice versa." code := MismatchedTypes ok, _ := x.assignableTo(check, y.typ, nil) if !ok { ok, _ = y.assignableTo(check, x.typ, nil) } if !ok { // Report the error on the 2nd operand since we only // know after seeing the 2nd operand whether we have // a type mismatch. errOp = y cause = check.sprintf("mismatched types %s and %s", x.typ, y.typ) goto Error } // check if comparison is defined for operands code = UndefinedOp switch op { case syntax.Eql, syntax.Neq: // spec: "The equality operators == and != apply to operands that are comparable." switch { case x.isNil() || y.isNil(): // Comparison against nil requires that the other operand type has nil. typ := x.typ if x.isNil() { typ = y.typ } if !hasNil(typ) { // This case should only be possible for "nil == nil". // Report the error on the 2nd operand since we only // know after seeing the 2nd operand whether we have // an invalid comparison. errOp = y goto Error } case !Comparable(x.typ): errOp = x cause = check.incomparableCause(x.typ) goto Error case !Comparable(y.typ): errOp = y cause = check.incomparableCause(y.typ) goto Error } case syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq: // spec: The ordering operators <, <=, >, and >= apply to operands that are ordered." switch { case !allOrdered(x.typ): errOp = x goto Error case !allOrdered(y.typ): errOp = y goto Error } default: unreachable() } // comparison is ok if x.mode == constant_ && y.mode == constant_ { x.val = constant.MakeBool(constant.Compare(x.val, op2tok[op], y.val)) // The operands are never materialized; no need to update // their types. } else { x.mode = value // The operands have now their final types, which at run- // time will be materialized. Update the expression trees. // If the current types are untyped, the materialized type // is the respective default type. check.updateExprType(x.expr, Default(x.typ), true) check.updateExprType(y.expr, Default(y.typ), true) } // spec: "Comparison operators compare two operands and yield // an untyped boolean value." x.typ = Typ[UntypedBool] return Error: // We have an offending operand errOp and possibly an error cause. if cause == "" { if isTypeParam(x.typ) || isTypeParam(y.typ) { // TODO(gri) should report the specific type causing the problem, if any if !isTypeParam(x.typ) { errOp = y } cause = check.sprintf("type parameter %s is not comparable with %s", errOp.typ, op) } else { cause = check.sprintf("operator %s not defined on %s", op, check.kindString(errOp.typ)) // catch-all } } if switchCase { check.errorf(x, code, "invalid case %s in switch on %s (%s)", x.expr, y.expr, cause) // error position always at 1st operand } else { check.errorf(errOp, code, invalidOp+"%s %s %s (%s)", x.expr, op, y.expr, cause) } x.mode = invalid } // incomparableCause returns a more specific cause why typ is not comparable. // If there is no more specific cause, the result is "". func (check *Checker) incomparableCause(typ Type) string { switch under(typ).(type) { case *Slice, *Signature, *Map: return check.kindString(typ) + " can only be compared to nil" } // see if we can extract a more specific error var cause string comparable(typ, true, nil, func(format string, args ...interface{}) { cause = check.sprintf(format, args...) }) return cause } // kindString returns the type kind as a string. func (check *Checker) kindString(typ Type) string { switch under(typ).(type) { case *Array: return "array" case *Slice: return "slice" case *Struct: return "struct" case *Pointer: return "pointer" case *Signature: return "func" case *Interface: if isTypeParam(typ) { return check.sprintf("type parameter %s", typ) } return "interface" case *Map: return "map" case *Chan: return "chan" default: return check.sprintf("%s", typ) // catch-all } } // If e != nil, it must be the shift expression; it may be nil for non-constant shifts. func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) { // TODO(gri) This function seems overly complex. Revisit. var xval constant.Value if x.mode == constant_ { xval = constant.ToInt(x.val) } if allInteger(x.typ) || isUntyped(x.typ) && xval != nil && xval.Kind() == constant.Int { // The lhs is of integer type or an untyped constant representable // as an integer. Nothing to do. } else { // shift has no chance check.errorf(x, InvalidShiftOperand, invalidOp+"shifted operand %s must be integer", x) x.mode = invalid return } // spec: "The right operand in a shift expression must have integer type // or be an untyped constant representable by a value of type uint." // Check that constants are representable by uint, but do not convert them // (see also go.dev/issue/47243). var yval constant.Value if y.mode == constant_ { // Provide a good error message for negative shift counts. yval = constant.ToInt(y.val) // consider -1, 1.0, but not -1.1 if yval.Kind() == constant.Int && constant.Sign(yval) < 0 { check.errorf(y, InvalidShiftCount, invalidOp+"negative shift count %s", y) x.mode = invalid return } if isUntyped(y.typ) { // Caution: Check for representability here, rather than in the switch // below, because isInteger includes untyped integers (was bug go.dev/issue/43697). check.representable(y, Typ[Uint]) if y.mode == invalid { x.mode = invalid return } } } else { // Check that RHS is otherwise at least of integer type. switch { case allInteger(y.typ): if !allUnsigned(y.typ) && !check.verifyVersionf(y, go1_13, invalidOp+"signed shift count %s", y) { x.mode = invalid return } case isUntyped(y.typ): // This is incorrect, but preserves pre-existing behavior. // See also go.dev/issue/47410. check.convertUntyped(y, Typ[Uint]) if y.mode == invalid { x.mode = invalid return } default: check.errorf(y, InvalidShiftCount, invalidOp+"shift count %s must be integer", y) x.mode = invalid return } } if x.mode == constant_ { if y.mode == constant_ { // if either x or y has an unknown value, the result is unknown if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown { x.val = constant.MakeUnknown() // ensure the correct type - see comment below if !isInteger(x.typ) { x.typ = Typ[UntypedInt] } return } // rhs must be within reasonable bounds in constant shifts const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see go.dev/issue/44057) s, ok := constant.Uint64Val(yval) if !ok || s > shiftBound { check.errorf(y, InvalidShiftCount, invalidOp+"invalid shift count %s", y) x.mode = invalid return } // The lhs is representable as an integer but may not be an integer // (e.g., 2.0, an untyped float) - this can only happen for untyped // non-integer numeric constants. Correct the type so that the shift // result is of integer type. if !isInteger(x.typ) { x.typ = Typ[UntypedInt] } // x is a constant so xval != nil and it must be of Int kind. x.val = constant.Shift(xval, op2tok[op], uint(s)) x.expr = e check.overflow(x, opPos(x.expr)) return } // non-constant shift with constant lhs if isUntyped(x.typ) { // spec: "If the left operand of a non-constant shift // expression is an untyped constant, the type of the // constant is what it would be if the shift expression // were replaced by its left operand alone.". // // Delay operand checking until we know the final type // by marking the lhs expression as lhs shift operand. // // Usually (in correct programs), the lhs expression // is in the untyped map. However, it is possible to // create incorrect programs where the same expression // is evaluated twice (via a declaration cycle) such // that the lhs expression type is determined in the // first round and thus deleted from the map, and then // not found in the second round (double insertion of // the same expr node still just leads to one entry for // that node, and it can only be deleted once). // Be cautious and check for presence of entry. // Example: var e, f = int(1<<""[f]) // go.dev/issue/11347 if info, found := check.untyped[x.expr]; found { info.isLhs = true check.untyped[x.expr] = info } // keep x's type x.mode = value return } } // non-constant shift - lhs must be an integer if !allInteger(x.typ) { check.errorf(x, InvalidShiftOperand, invalidOp+"shifted operand %s must be integer", x) x.mode = invalid return } x.mode = value } var binaryOpPredicates opPredicates func init() { // Setting binaryOpPredicates in init avoids declaration cycles. binaryOpPredicates = opPredicates{ syntax.Add: allNumericOrString, syntax.Sub: allNumeric, syntax.Mul: allNumeric, syntax.Div: allNumeric, syntax.Rem: allInteger, syntax.And: allInteger, syntax.Or: allInteger, syntax.Xor: allInteger, syntax.AndNot: allInteger, syntax.AndAnd: allBoolean, syntax.OrOr: allBoolean, } } // If e != nil, it must be the binary expression; it may be nil for non-constant expressions // (when invoked for an assignment operation where the binary expression is implicit). func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op syntax.Operator) { var y operand check.expr(nil, x, lhs) check.expr(nil, &y, rhs) if x.mode == invalid { return } if y.mode == invalid { x.mode = invalid x.expr = y.expr return } if isShift(op) { check.shift(x, &y, e, op) return } check.matchTypes(x, &y) if x.mode == invalid { return } if isComparison(op) { check.comparison(x, &y, op, false) return } if !Identical(x.typ, y.typ) { // only report an error if we have valid types // (otherwise we had an error reported elsewhere already) if isValid(x.typ) && isValid(y.typ) { if e != nil { check.errorf(x, MismatchedTypes, invalidOp+"%s (mismatched types %s and %s)", e, x.typ, y.typ) } else { check.errorf(x, MismatchedTypes, invalidOp+"%s %s= %s (mismatched types %s and %s)", lhs, op, rhs, x.typ, y.typ) } } x.mode = invalid return } if !check.op(binaryOpPredicates, x, op) { x.mode = invalid return } if op == syntax.Div || op == syntax.Rem { // check for zero divisor if (x.mode == constant_ || allInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 { check.error(&y, DivByZero, invalidOp+"division by zero") x.mode = invalid return } // check for divisor underflow in complex division (see go.dev/issue/20227) if x.mode == constant_ && y.mode == constant_ && isComplex(x.typ) { re, im := constant.Real(y.val), constant.Imag(y.val) re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im) if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 { check.error(&y, DivByZero, invalidOp+"division by zero") x.mode = invalid return } } } if x.mode == constant_ && y.mode == constant_ { // if either x or y has an unknown value, the result is unknown if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown { x.val = constant.MakeUnknown() // x.typ is unchanged return } // force integer division for integer operands tok := op2tok[op] if op == syntax.Div && isInteger(x.typ) { tok = token.QUO_ASSIGN } x.val = constant.BinaryOp(x.val, tok, y.val) x.expr = e check.overflow(x, opPos(x.expr)) return } x.mode = value // x.typ is unchanged } // matchTypes attempts to convert any untyped types x and y such that they match. // If an error occurs, x.mode is set to invalid. func (check *Checker) matchTypes(x, y *operand) { // mayConvert reports whether the operands x and y may // possibly have matching types after converting one // untyped operand to the type of the other. // If mayConvert returns true, we try to convert the // operands to each other's types, and if that fails // we report a conversion failure. // If mayConvert returns false, we continue without an // attempt at conversion, and if the operand types are // not compatible, we report a type mismatch error. mayConvert := func(x, y *operand) bool { // If both operands are typed, there's no need for an implicit conversion. if isTyped(x.typ) && isTyped(y.typ) { return false } // An untyped operand may convert to its default type when paired with an empty interface // TODO(gri) This should only matter for comparisons (the only binary operation that is // valid with interfaces), but in that case the assignability check should take // care of the conversion. Verify and possibly eliminate this extra test. if isNonTypeParamInterface(x.typ) || isNonTypeParamInterface(y.typ) { return true } // A boolean type can only convert to another boolean type. if allBoolean(x.typ) != allBoolean(y.typ) { return false } // A string type can only convert to another string type. if allString(x.typ) != allString(y.typ) { return false } // Untyped nil can only convert to a type that has a nil. if x.isNil() { return hasNil(y.typ) } if y.isNil() { return hasNil(x.typ) } // An untyped operand cannot convert to a pointer. // TODO(gri) generalize to type parameters if isPointer(x.typ) || isPointer(y.typ) { return false } return true } if mayConvert(x, y) { check.convertUntyped(x, y.typ) if x.mode == invalid { return } check.convertUntyped(y, x.typ) if y.mode == invalid { x.mode = invalid return } } } // exprKind describes the kind of an expression; the kind // determines if an expression is valid in 'statement context'. type exprKind int const ( conversion exprKind = iota expression statement ) // target represent the (signature) type and description of the LHS // variable of an assignment, or of a function result variable. type target struct { sig *Signature desc string } // newTarget creates a new target for the given type and description. // The result is nil if typ is not a signature. func newTarget(typ Type, desc string) *target { if typ != nil { if sig, _ := under(typ).(*Signature); sig != nil { return &target{sig, desc} } } return nil } // rawExpr typechecks expression e and initializes x with the expression // value or type. If an error occurred, x.mode is set to invalid. // If a non-nil target T is given and e is a generic function, // T is used to infer the type arguments for e. // If hint != nil, it is the type of a composite literal element. // If allowGeneric is set, the operand type may be an uninstantiated // parameterized type or function value. func (check *Checker) rawExpr(T *target, x *operand, e syntax.Expr, hint Type, allowGeneric bool) exprKind { if check.conf.Trace { check.trace(e.Pos(), "-- expr %s", e) check.indent++ defer func() { check.indent-- check.trace(e.Pos(), "=> %s", x) }() } kind := check.exprInternal(T, x, e, hint) if !allowGeneric { check.nonGeneric(T, x) } check.record(x) return kind } // If x is a generic type, or a generic function whose type arguments cannot be inferred // from a non-nil target T, nonGeneric reports an error and invalidates x.mode and x.typ. // Otherwise it leaves x alone. func (check *Checker) nonGeneric(T *target, x *operand) { if x.mode == invalid || x.mode == novalue { return } var what string switch t := x.typ.(type) { case *Named: if isGeneric(t) { what = "type" } case *Signature: if t.tparams != nil { if enableReverseTypeInference && T != nil { check.funcInst(T, x.Pos(), x, nil, true) return } what = "function" } } if what != "" { check.errorf(x.expr, WrongTypeArgCount, "cannot use generic %s %s without instantiation", what, x.expr) x.mode = invalid x.typ = Typ[Invalid] } } // exprInternal contains the core of type checking of expressions. // Must only be called by rawExpr. // (See rawExpr for an explanation of the parameters.) func (check *Checker) exprInternal(T *target, x *operand, e syntax.Expr, hint Type) exprKind { // make sure x has a valid state in case of bailout // (was go.dev/issue/5770) x.mode = invalid x.typ = Typ[Invalid] switch e := e.(type) { case nil: unreachable() case *syntax.BadExpr: goto Error // error was reported before case *syntax.Name: check.ident(x, e, nil, false) case *syntax.DotsType: // dots are handled explicitly where they are legal // (array composite literals and parameter lists) check.error(e, BadDotDotDotSyntax, "invalid use of '...'") goto Error case *syntax.BasicLit: if e.Bad { goto Error // error reported during parsing } switch e.Kind { case syntax.IntLit, syntax.FloatLit, syntax.ImagLit: check.langCompat(e) // The max. mantissa precision for untyped numeric values // is 512 bits, or 4048 bits for each of the two integer // parts of a fraction for floating-point numbers that are // represented accurately in the go/constant package. // Constant literals that are longer than this many bits // are not meaningful; and excessively long constants may // consume a lot of space and time for a useless conversion. // Cap constant length with a generous upper limit that also // allows for separators between all digits. const limit = 10000 if len(e.Value) > limit { check.errorf(e, InvalidConstVal, "excessively long constant: %s... (%d chars)", e.Value[:10], len(e.Value)) goto Error } } x.setConst(e.Kind, e.Value) if x.mode == invalid { // The parser already establishes syntactic correctness. // If we reach here it's because of number under-/overflow. // TODO(gri) setConst (and in turn the go/constant package) // should return an error describing the issue. check.errorf(e, InvalidConstVal, "malformed constant: %s", e.Value) goto Error } // Ensure that integer values don't overflow (go.dev/issue/54280). x.expr = e // make sure that check.overflow below has an error position check.overflow(x, opPos(x.expr)) case *syntax.FuncLit: if sig, ok := check.typ(e.Type).(*Signature); ok { // Set the Scope's extent to the complete "func (...) {...}" // so that Scope.Innermost works correctly. sig.scope.pos = e.Pos() sig.scope.end = syntax.EndPos(e) if !check.conf.IgnoreFuncBodies && e.Body != nil { // Anonymous functions are considered part of the // init expression/func declaration which contains // them: use existing package-level declaration info. decl := check.decl // capture for use in closure below iota := check.iota // capture for use in closure below (go.dev/issue/22345) // Don't type-check right away because the function may // be part of a type definition to which the function // body refers. Instead, type-check as soon as possible, // but before the enclosing scope contents changes (go.dev/issue/22992). check.later(func() { check.funcBody(decl, "<function literal>", sig, e.Body, iota) }).describef(e, "func literal") } x.mode = value x.typ = sig } else { check.errorf(e, InvalidSyntaxTree, "invalid function literal %v", e) goto Error } case *syntax.CompositeLit: var typ, base Type switch { case e.Type != nil: // composite literal type present - use it // [...]T array types may only appear with composite literals. // Check for them here so we don't have to handle ... in general. if atyp, _ := e.Type.(*syntax.ArrayType); atyp != nil && atyp.Len == nil { // We have an "open" [...]T array type. // Create a new ArrayType with unknown length (-1) // and finish setting it up after analyzing the literal. typ = &Array{len: -1, elem: check.varType(atyp.Elem)} base = typ break } typ = check.typ(e.Type) base = typ case hint != nil: // no composite literal type present - use hint (element type of enclosing type) typ = hint base, _ = deref(coreType(typ)) // *T implies &T{} if base == nil { check.errorf(e, InvalidLit, "invalid composite literal element type %s (no core type)", typ) goto Error } default: // TODO(gri) provide better error messages depending on context check.error(e, UntypedLit, "missing type in composite literal") goto Error } switch utyp := coreType(base).(type) { case *Struct: // Prevent crash if the struct referred to is not yet set up. // See analogous comment for *Array. if utyp.fields == nil { check.error(e, InvalidTypeCycle, "invalid recursive type") goto Error } if len(e.ElemList) == 0 { break } // Convention for error messages on invalid struct literals: // we mention the struct type only if it clarifies the error // (e.g., a duplicate field error doesn't need the struct type). fields := utyp.fields if _, ok := e.ElemList[0].(*syntax.KeyValueExpr); ok { // all elements must have keys visited := make([]bool, len(fields)) for _, e := range e.ElemList { kv, _ := e.(*syntax.KeyValueExpr) if kv == nil { check.error(e, MixedStructLit, "mixture of field:value and value elements in struct literal") continue } key, _ := kv.Key.(*syntax.Name) // do all possible checks early (before exiting due to errors) // so we don't drop information on the floor check.expr(nil, x, kv.Value) if key == nil { check.errorf(kv, InvalidLitField, "invalid field name %s in struct literal", kv.Key) continue } i := fieldIndex(utyp.fields, check.pkg, key.Value) if i < 0 { check.errorf(kv.Key, MissingLitField, "unknown field %s in struct literal of type %s", key.Value, base) continue } fld := fields[i] check.recordUse(key, fld) etyp := fld.typ check.assignment(x, etyp, "struct literal") // 0 <= i < len(fields) if visited[i] { check.errorf(kv, DuplicateLitField, "duplicate field name %s in struct literal", key.Value) continue } visited[i] = true } } else { // no element must have a key for i, e := range e.ElemList { if kv, _ := e.(*syntax.KeyValueExpr); kv != nil { check.error(kv, MixedStructLit, "mixture of field:value and value elements in struct literal") continue } check.expr(nil, x, e) if i >= len(fields) { check.errorf(x, InvalidStructLit, "too many values in struct literal of type %s", base) break // cannot continue } // i < len(fields) fld := fields[i] if !fld.Exported() && fld.pkg != check.pkg { check.errorf(x, UnexportedLitField, "implicit assignment to unexported field %s in struct literal of type %s", fld.name, base) continue } etyp := fld.typ check.assignment(x, etyp, "struct literal") } if len(e.ElemList) < len(fields) { check.errorf(e.Rbrace, InvalidStructLit, "too few values in struct literal of type %s", base) // ok to continue } } case *Array: // Prevent crash if the array referred to is not yet set up. Was go.dev/issue/18643. // This is a stop-gap solution. Should use Checker.objPath to report entire // path starting with earliest declaration in the source. TODO(gri) fix this. if utyp.elem == nil { check.error(e, InvalidTypeCycle, "invalid recursive type") goto Error } n := check.indexedElts(e.ElemList, utyp.elem, utyp.len) // If we have an array of unknown length (usually [...]T arrays, but also // arrays [n]T where n is invalid) set the length now that we know it and // record the type for the array (usually done by check.typ which is not // called for [...]T). We handle [...]T arrays and arrays with invalid // length the same here because it makes sense to "guess" the length for // the latter if we have a composite literal; e.g. for [n]int{1, 2, 3} // where n is invalid for some reason, it seems fair to assume it should // be 3 (see also Checked.arrayLength and go.dev/issue/27346). if utyp.len < 0 { utyp.len = n // e.Type is missing if we have a composite literal element // that is itself a composite literal with omitted type. In // that case there is nothing to record (there is no type in // the source at that point). if e.Type != nil { check.recordTypeAndValue(e.Type, typexpr, utyp, nil) } } case *Slice: // Prevent crash if the slice referred to is not yet set up. // See analogous comment for *Array. if utyp.elem == nil { check.error(e, InvalidTypeCycle, "invalid recursive type") goto Error } check.indexedElts(e.ElemList, utyp.elem, -1) case *Map: // Prevent crash if the map referred to is not yet set up. // See analogous comment for *Array. if utyp.key == nil || utyp.elem == nil { check.error(e, InvalidTypeCycle, "invalid recursive type") goto Error } // If the map key type is an interface (but not a type parameter), // the type of a constant key must be considered when checking for // duplicates. keyIsInterface := isNonTypeParamInterface(utyp.key) visited := make(map[interface{}][]Type, len(e.ElemList)) for _, e := range e.ElemList { kv, _ := e.(*syntax.KeyValueExpr) if kv == nil { check.error(e, MissingLitKey, "missing key in map literal") continue } check.exprWithHint(x, kv.Key, utyp.key) check.assignment(x, utyp.key, "map literal") if x.mode == invalid { continue } if x.mode == constant_ { duplicate := false xkey := keyVal(x.val) if keyIsInterface { for _, vtyp := range visited[xkey] { if Identical(vtyp, x.typ) { duplicate = true break } } visited[xkey] = append(visited[xkey], x.typ) } else { _, duplicate = visited[xkey] visited[xkey] = nil } if duplicate { check.errorf(x, DuplicateLitKey, "duplicate key %s in map literal", x.val) continue } } check.exprWithHint(x, kv.Value, utyp.elem) check.assignment(x, utyp.elem, "map literal") } default: // when "using" all elements unpack KeyValueExpr // explicitly because check.use doesn't accept them for _, e := range e.ElemList { if kv, _ := e.(*syntax.KeyValueExpr); kv != nil { // Ideally, we should also "use" kv.Key but we can't know // if it's an externally defined struct key or not. Going // forward anyway can lead to other errors. Give up instead. e = kv.Value } check.use(e) } // if utyp is invalid, an error was reported before if isValid(utyp) { check.errorf(e, InvalidLit, "invalid composite literal type %s", typ) goto Error } } x.mode = value x.typ = typ case *syntax.ParenExpr: // type inference doesn't go past parentheses (targe type T = nil) kind := check.rawExpr(nil, x, e.X, nil, false) x.expr = e return kind case *syntax.SelectorExpr: check.selector(x, e, nil, false) case *syntax.IndexExpr: if check.indexExpr(x, e) { if !enableReverseTypeInference { T = nil } check.funcInst(T, e.Pos(), x, e, true) } if x.mode == invalid { goto Error } case *syntax.SliceExpr: check.sliceExpr(x, e) if x.mode == invalid { goto Error } case *syntax.AssertExpr: check.expr(nil, x, e.X) if x.mode == invalid { goto Error } // x.(type) expressions are encoded via TypeSwitchGuards if e.Type == nil { check.error(e, InvalidSyntaxTree, "invalid use of AssertExpr") goto Error } if isTypeParam(x.typ) { check.errorf(x, InvalidAssert, invalidOp+"cannot use type assertion on type parameter value %s", x) goto Error } if _, ok := under(x.typ).(*Interface); !ok { check.errorf(x, InvalidAssert, invalidOp+"%s is not an interface", x) goto Error } T := check.varType(e.Type) if !isValid(T) { goto Error } check.typeAssertion(e, x, T, false) x.mode = commaok x.typ = T case *syntax.TypeSwitchGuard: // x.(type) expressions are handled explicitly in type switches check.error(e, InvalidSyntaxTree, "use of .(type) outside type switch") check.use(e.X) goto Error case *syntax.CallExpr: return check.callExpr(x, e) case *syntax.ListExpr: // catch-all for unexpected expression lists check.error(e, InvalidSyntaxTree, "unexpected list of expressions") goto Error // case *syntax.UnaryExpr: // check.expr(x, e.X) // if x.mode == invalid { // goto Error // } // check.unary(x, e, e.Op) // if x.mode == invalid { // goto Error // } // if e.Op == token.ARROW { // x.expr = e // return statement // receive operations may appear in statement context // } // case *syntax.BinaryExpr: // check.binary(x, e, e.X, e.Y, e.Op) // if x.mode == invalid { // goto Error // } case *syntax.Operation: if e.Y == nil { // unary expression if e.Op == syntax.Mul { // pointer indirection check.exprOrType(x, e.X, false) switch x.mode { case invalid: goto Error case typexpr: check.validVarType(e.X, x.typ) x.typ = &Pointer{base: x.typ} default: var base Type if !underIs(x.typ, func(u Type) bool { p, _ := u.(*Pointer) if p == nil { check.errorf(x, InvalidIndirection, invalidOp+"cannot indirect %s", x) return false } if base != nil && !Identical(p.base, base) { check.errorf(x, InvalidIndirection, invalidOp+"pointers of %s must have identical base types", x) return false } base = p.base return true }) { goto Error } x.mode = variable x.typ = base } break } check.unary(x, e) if x.mode == invalid { goto Error } if e.Op == syntax.Recv { x.expr = e return statement // receive operations may appear in statement context } break } // binary expression check.binary(x, e, e.X, e.Y, e.Op) if x.mode == invalid { goto Error } case *syntax.KeyValueExpr: // key:value expressions are handled in composite literals check.error(e, InvalidSyntaxTree, "no key:value expected") goto Error case *syntax.ArrayType, *syntax.SliceType, *syntax.StructType, *syntax.FuncType, *syntax.InterfaceType, *syntax.MapType, *syntax.ChanType: x.mode = typexpr x.typ = check.typ(e) // Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue // even though check.typ has already called it. This is fine as both // times the same expression and type are recorded. It is also not a // performance issue because we only reach here for composite literal // types, which are comparatively rare. default: panic(fmt.Sprintf("%s: unknown expression type %T", atPos(e), e)) } // everything went well x.expr = e return expression Error: x.mode = invalid x.expr = e return statement // avoid follow-up errors } // keyVal maps a complex, float, integer, string or boolean constant value // to the corresponding complex128, float64, int64, uint64, string, or bool // Go value if possible; otherwise it returns x. // A complex constant that can be represented as a float (such as 1.2 + 0i) // is returned as a floating point value; if a floating point value can be // represented as an integer (such as 1.0) it is returned as an integer value. // This ensures that constants of different kind but equal value (such as // 1.0 + 0i, 1.0, 1) result in the same value. func keyVal(x constant.Value) interface{} { switch x.Kind() { case constant.Complex: f := constant.ToFloat(x) if f.Kind() != constant.Float { r, _ := constant.Float64Val(constant.Real(x)) i, _ := constant.Float64Val(constant.Imag(x)) return complex(r, i) } x = f fallthrough case constant.Float: i := constant.ToInt(x) if i.Kind() != constant.Int { v, _ := constant.Float64Val(x) return v } x = i fallthrough case constant.Int: if v, ok := constant.Int64Val(x); ok { return v } if v, ok := constant.Uint64Val(x); ok { return v } case constant.String: return constant.StringVal(x) case constant.Bool: return constant.BoolVal(x) } return x } // typeAssertion checks x.(T). The type of x must be an interface. func (check *Checker) typeAssertion(e syntax.Expr, x *operand, T Type, typeSwitch bool) { var cause string if check.assertableTo(x.typ, T, &cause) { return // success } if typeSwitch { check.errorf(e, ImpossibleAssert, "impossible type switch case: %s\n\t%s cannot have dynamic type %s %s", e, x, T, cause) return } check.errorf(e, ImpossibleAssert, "impossible type assertion: %s\n\t%s does not implement %s %s", e, T, x.typ, cause) } // expr typechecks expression e and initializes x with the expression value. // If a non-nil target T is given and e is a generic function or // a function call, T is used to infer the type arguments for e. // The result must be a single value. // If an error occurred, x.mode is set to invalid. func (check *Checker) expr(T *target, x *operand, e syntax.Expr) { check.rawExpr(T, x, e, nil, false) check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr) check.singleValue(x) } // genericExpr is like expr but the result may also be generic. func (check *Checker) genericExpr(x *operand, e syntax.Expr) { check.rawExpr(nil, x, e, nil, true) check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr) check.singleValue(x) } // multiExpr typechecks e and returns its value (or values) in list. // If allowCommaOk is set and e is a map index, comma-ok, or comma-err // expression, the result is a two-element list containing the value // of e, and an untyped bool value or an error value, respectively. // If an error occurred, list[0] is not valid. func (check *Checker) multiExpr(e syntax.Expr, allowCommaOk bool) (list []*operand, commaOk bool) { var x operand check.rawExpr(nil, &x, e, nil, false) check.exclude(&x, 1<<novalue|1<<builtin|1<<typexpr) if t, ok := x.typ.(*Tuple); ok && x.mode != invalid { // multiple values list = make([]*operand, t.Len()) for i, v := range t.vars { list[i] = &operand{mode: value, expr: e, typ: v.typ} } return } // exactly one (possibly invalid or comma-ok) value list = []*operand{&x} if allowCommaOk && (x.mode == mapindex || x.mode == commaok || x.mode == commaerr) { x2 := &operand{mode: value, expr: e, typ: Typ[UntypedBool]} if x.mode == commaerr { x2.typ = universeError } list = append(list, x2) commaOk = true } return } // exprWithHint typechecks expression e and initializes x with the expression value; // hint is the type of a composite literal element. // If an error occurred, x.mode is set to invalid. func (check *Checker) exprWithHint(x *operand, e syntax.Expr, hint Type) { assert(hint != nil) check.rawExpr(nil, x, e, hint, false) check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr) check.singleValue(x) } // exprOrType typechecks expression or type e and initializes x with the expression value or type. // If allowGeneric is set, the operand type may be an uninstantiated parameterized type or function // value. // If an error occurred, x.mode is set to invalid. func (check *Checker) exprOrType(x *operand, e syntax.Expr, allowGeneric bool) { check.rawExpr(nil, x, e, nil, allowGeneric) check.exclude(x, 1<<novalue) check.singleValue(x) } // exclude reports an error if x.mode is in modeset and sets x.mode to invalid. // The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr. func (check *Checker) exclude(x *operand, modeset uint) { if modeset&(1<<x.mode) != 0 { var msg string var code Code switch x.mode { case novalue: if modeset&(1<<typexpr) != 0 { msg = "%s used as value" } else { msg = "%s used as value or type" } code = TooManyValues case builtin: msg = "%s must be called" code = UncalledBuiltin case typexpr: msg = "%s is not an expression" code = NotAnExpr default: unreachable() } check.errorf(x, code, msg, x) x.mode = invalid } } // singleValue reports an error if x describes a tuple and sets x.mode to invalid. func (check *Checker) singleValue(x *operand) { if x.mode == value { // tuple types are never named - no need for underlying type below if t, ok := x.typ.(*Tuple); ok { assert(t.Len() != 1) check.errorf(x, TooManyValues, "multiple-value %s in single-value context", x) x.mode = invalid } } } // op2tok translates syntax.Operators into token.Tokens. var op2tok = [...]token.Token{ syntax.Def: token.ILLEGAL, syntax.Not: token.NOT, syntax.Recv: token.ILLEGAL, syntax.OrOr: token.LOR, syntax.AndAnd: token.LAND, syntax.Eql: token.EQL, syntax.Neq: token.NEQ, syntax.Lss: token.LSS, syntax.Leq: token.LEQ, syntax.Gtr: token.GTR, syntax.Geq: token.GEQ, syntax.Add: token.ADD, syntax.Sub: token.SUB, syntax.Or: token.OR, syntax.Xor: token.XOR, syntax.Mul: token.MUL, syntax.Div: token.QUO, syntax.Rem: token.REM, syntax.And: token.AND, syntax.AndNot: token.AND_NOT, syntax.Shl: token.SHL, syntax.Shr: token.SHR, } PK ! &cˠ � objset.gonu �[��� // Copyright 2013 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. // This file implements objsets. // // An objset is similar to a Scope but objset elements // are identified by their unique id, instead of their // object name. package types2 // An objset is a set of objects identified by their unique id. // The zero value for objset is a ready-to-use empty objset. type objset map[string]Object // initialized lazily // insert attempts to insert an object obj into objset s. // If s already contains an alternative object alt with // the same name, insert leaves s unchanged and returns alt. // Otherwise it inserts obj and returns nil. func (s *objset) insert(obj Object) Object { id := obj.Id() if alt := (*s)[id]; alt != nil { return alt } if *s == nil { *s = make(map[string]Object) } (*s)[id] = obj return nil } PK ! ���� � interface.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" ) // ---------------------------------------------------------------------------- // API // An Interface represents an interface type. type Interface struct { check *Checker // for error reporting; nil once type set is computed methods []*Func // ordered list of explicitly declared methods embeddeds []Type // ordered list of explicitly embedded elements embedPos *[]syntax.Pos // positions of embedded elements; or nil (for error messages) - use pointer to save space implicit bool // interface is wrapper for type set literal (non-interface T, ~T, or A|B) complete bool // indicates that all fields (except for tset) are set up tset *_TypeSet // type set described by this interface, computed lazily } // typeSet returns the type set for interface t. func (t *Interface) typeSet() *_TypeSet { return computeInterfaceTypeSet(t.check, nopos, t) } // emptyInterface represents the empty interface var emptyInterface = Interface{complete: true, tset: &topTypeSet} // NewInterfaceType returns a new interface for the given methods and embedded types. // NewInterfaceType takes ownership of the provided methods and may modify their types // by setting missing receivers. func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface { if len(methods) == 0 && len(embeddeds) == 0 { return &emptyInterface } // set method receivers if necessary typ := (*Checker)(nil).newInterface() for _, m := range methods { if sig := m.typ.(*Signature); sig.recv == nil { sig.recv = NewVar(m.pos, m.pkg, "", typ) } } // sort for API stability sortMethods(methods) typ.methods = methods typ.embeddeds = embeddeds typ.complete = true return typ } // check may be nil func (check *Checker) newInterface() *Interface { typ := &Interface{check: check} if check != nil { check.needsCleanup(typ) } return typ } // MarkImplicit marks the interface t as implicit, meaning this interface // corresponds to a constraint literal such as ~T or A|B without explicit // interface embedding. MarkImplicit should be called before any concurrent use // of implicit interfaces. func (t *Interface) MarkImplicit() { t.implicit = true } // NumExplicitMethods returns the number of explicitly declared methods of interface t. func (t *Interface) NumExplicitMethods() int { return len(t.methods) } // ExplicitMethod returns the i'th explicitly declared method of interface t for 0 <= i < t.NumExplicitMethods(). // The methods are ordered by their unique Id. func (t *Interface) ExplicitMethod(i int) *Func { return t.methods[i] } // NumEmbeddeds returns the number of embedded types in interface t. func (t *Interface) NumEmbeddeds() int { return len(t.embeddeds) } // EmbeddedType returns the i'th embedded type of interface t for 0 <= i < t.NumEmbeddeds(). func (t *Interface) EmbeddedType(i int) Type { return t.embeddeds[i] } // NumMethods returns the total number of methods of interface t. func (t *Interface) NumMethods() int { return t.typeSet().NumMethods() } // Method returns the i'th method of interface t for 0 <= i < t.NumMethods(). // The methods are ordered by their unique Id. func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) } // Empty reports whether t is the empty interface. func (t *Interface) Empty() bool { return t.typeSet().IsAll() } // IsComparable reports whether each type in interface t's type set is comparable. func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable(nil) } // IsMethodSet reports whether the interface t is fully described by its method set. func (t *Interface) IsMethodSet() bool { return t.typeSet().IsMethodSet() } // IsImplicit reports whether the interface t is a wrapper for a type set literal. func (t *Interface) IsImplicit() bool { return t.implicit } func (t *Interface) Underlying() Type { return t } func (t *Interface) String() string { return TypeString(t, nil) } // ---------------------------------------------------------------------------- // Implementation func (t *Interface) cleanup() { t.typeSet() // any interface that escapes type checking must be safe for concurrent use t.check = nil t.embedPos = nil } func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType, def *TypeName) { addEmbedded := func(pos syntax.Pos, typ Type) { ityp.embeddeds = append(ityp.embeddeds, typ) if ityp.embedPos == nil { ityp.embedPos = new([]syntax.Pos) } *ityp.embedPos = append(*ityp.embedPos, pos) } for _, f := range iface.MethodList { if f.Name == nil { addEmbedded(atPos(f.Type), parseUnion(check, f.Type)) continue } // f.Name != nil // We have a method with name f.Name. name := f.Name.Value if name == "_" { check.error(f.Name, BlankIfaceMethod, "methods must have a unique non-blank name") continue // ignore } typ := check.typ(f.Type) sig, _ := typ.(*Signature) if sig == nil { if isValid(typ) { check.errorf(f.Type, InvalidSyntaxTree, "%s is not a method signature", typ) } continue // ignore } // use named receiver type if available (for better error messages) var recvTyp Type = ityp if def != nil { if named := asNamed(def.typ); named != nil { recvTyp = named } } sig.recv = NewVar(f.Name.Pos(), check.pkg, "", recvTyp) m := NewFunc(f.Name.Pos(), check.pkg, name, sig) check.recordDef(f.Name, m) ityp.methods = append(ityp.methods, m) } // All methods and embedded elements for this interface are collected; // i.e., this interface may be used in a type set computation. ityp.complete = true if len(ityp.methods) == 0 && len(ityp.embeddeds) == 0 { // empty interface ityp.tset = &topTypeSet return } // sort for API stability // (don't sort embeddeds: they must correspond to *embedPos entries) sortMethods(ityp.methods) // Compute type set as soon as possible to report any errors. // Subsequent uses of type sets will use this computed type // set and won't need to pass in a *Checker. check.later(func() { computeInterfaceTypeSet(check, iface.Pos(), ityp) }).describef(iface, "compute type set for %s", ityp) } PK ! )��6# 6# sizes.gonu �[��� // Copyright 2013 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. // This file implements Sizes. package types2 // Sizes defines the sizing functions for package unsafe. type Sizes interface { // Alignof returns the alignment of a variable of type T. // Alignof must implement the alignment guarantees required by the spec. // The result must be >= 1. Alignof(T Type) int64 // Offsetsof returns the offsets of the given struct fields, in bytes. // Offsetsof must implement the offset guarantees required by the spec. // A negative entry in the result indicates that the struct is too large. Offsetsof(fields []*Var) []int64 // Sizeof returns the size of a variable of type T. // Sizeof must implement the size guarantees required by the spec. // A negative result indicates that T is too large. Sizeof(T Type) int64 } // StdSizes is a convenience type for creating commonly used Sizes. // It makes the following simplifying assumptions: // // - The size of explicitly sized basic types (int16, etc.) is the // specified size. // - The size of strings and interfaces is 2*WordSize. // - The size of slices is 3*WordSize. // - The size of an array of n elements corresponds to the size of // a struct of n consecutive fields of the array's element type. // - The size of a struct is the offset of the last field plus that // field's size. As with all element types, if the struct is used // in an array its size must first be aligned to a multiple of the // struct's alignment. // - All other types have size WordSize. // - Arrays and structs are aligned per spec definition; all other // types are naturally aligned with a maximum alignment MaxAlign. // // *StdSizes implements Sizes. type StdSizes struct { WordSize int64 // word size in bytes - must be >= 4 (32bits) MaxAlign int64 // maximum alignment in bytes - must be >= 1 } func (s *StdSizes) Alignof(T Type) (result int64) { defer func() { assert(result >= 1) }() // For arrays and structs, alignment is defined in terms // of alignment of the elements and fields, respectively. switch t := under(T).(type) { case *Array: // spec: "For a variable x of array type: unsafe.Alignof(x) // is the same as unsafe.Alignof(x[0]), but at least 1." return s.Alignof(t.elem) case *Struct: if len(t.fields) == 0 && IsSyncAtomicAlign64(T) { // Special case: sync/atomic.align64 is an // empty struct we recognize as a signal that // the struct it contains must be // 64-bit-aligned. // // This logic is equivalent to the logic in // cmd/compile/internal/types/size.go:calcStructOffset return 8 } // spec: "For a variable x of struct type: unsafe.Alignof(x) // is the largest of the values unsafe.Alignof(x.f) for each // field f of x, but at least 1." max := int64(1) for _, f := range t.fields { if a := s.Alignof(f.typ); a > max { max = a } } return max case *Slice, *Interface: // Multiword data structures are effectively structs // in which each element has size WordSize. // Type parameters lead to variable sizes/alignments; // StdSizes.Alignof won't be called for them. assert(!isTypeParam(T)) return s.WordSize case *Basic: // Strings are like slices and interfaces. if t.Info()&IsString != 0 { return s.WordSize } case *TypeParam, *Union: unreachable() } a := s.Sizeof(T) // may be 0 or negative // spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1." if a < 1 { return 1 } // complex{64,128} are aligned like [2]float{32,64}. if isComplex(T) { a /= 2 } if a > s.MaxAlign { return s.MaxAlign } return a } func IsSyncAtomicAlign64(T Type) bool { named := asNamed(T) if named == nil { return false } obj := named.Obj() return obj.Name() == "align64" && obj.Pkg() != nil && (obj.Pkg().Path() == "sync/atomic" || obj.Pkg().Path() == "runtime/internal/atomic") } func (s *StdSizes) Offsetsof(fields []*Var) []int64 { offsets := make([]int64, len(fields)) var offs int64 for i, f := range fields { if offs < 0 { // all remaining offsets are too large offsets[i] = -1 continue } // offs >= 0 a := s.Alignof(f.typ) offs = align(offs, a) // possibly < 0 if align overflows offsets[i] = offs if d := s.Sizeof(f.typ); d >= 0 && offs >= 0 { offs += d // ok to overflow to < 0 } else { offs = -1 // f.typ or offs is too large } } return offsets } var basicSizes = [...]byte{ Bool: 1, Int8: 1, Int16: 2, Int32: 4, Int64: 8, Uint8: 1, Uint16: 2, Uint32: 4, Uint64: 8, Float32: 4, Float64: 8, Complex64: 8, Complex128: 16, } func (s *StdSizes) Sizeof(T Type) int64 { switch t := under(T).(type) { case *Basic: assert(isTyped(T)) k := t.kind if int(k) < len(basicSizes) { if s := basicSizes[k]; s > 0 { return int64(s) } } if k == String { return s.WordSize * 2 } case *Array: n := t.len if n <= 0 { return 0 } // n > 0 esize := s.Sizeof(t.elem) if esize < 0 { return -1 // element too large } if esize == 0 { return 0 // 0-size element } // esize > 0 a := s.Alignof(t.elem) ea := align(esize, a) // possibly < 0 if align overflows if ea < 0 { return -1 } // ea >= 1 n1 := n - 1 // n1 >= 0 // Final size is ea*n1 + esize; and size must be <= maxInt64. const maxInt64 = 1<<63 - 1 if n1 > 0 && ea > maxInt64/n1 { return -1 // ea*n1 overflows } return ea*n1 + esize // may still overflow to < 0 which is ok case *Slice: return s.WordSize * 3 case *Struct: n := t.NumFields() if n == 0 { return 0 } offsets := s.Offsetsof(t.fields) offs := offsets[n-1] size := s.Sizeof(t.fields[n-1].typ) if offs < 0 || size < 0 { return -1 // type too large } return offs + size // may overflow to < 0 which is ok case *Interface: // Type parameters lead to variable sizes/alignments; // StdSizes.Sizeof won't be called for them. assert(!isTypeParam(T)) return s.WordSize * 2 case *TypeParam, *Union: unreachable() } return s.WordSize // catch-all } // common architecture word sizes and alignments var gcArchSizes = map[string]*gcSizes{ "386": {4, 4}, "amd64": {8, 8}, "amd64p32": {4, 8}, "arm": {4, 4}, "arm64": {8, 8}, "loong64": {8, 8}, "mips": {4, 4}, "mipsle": {4, 4}, "mips64": {8, 8}, "mips64le": {8, 8}, "ppc64": {8, 8}, "ppc64le": {8, 8}, "riscv64": {8, 8}, "s390x": {8, 8}, "sparc64": {8, 8}, "wasm": {8, 8}, // When adding more architectures here, // update the doc string of SizesFor below. } // SizesFor returns the Sizes used by a compiler for an architecture. // The result is nil if a compiler/architecture pair is not known. // // Supported architectures for compiler "gc": // "386", "amd64", "amd64p32", "arm", "arm64", "loong64", "mips", "mipsle", // "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "sparc64", "wasm". func SizesFor(compiler, arch string) Sizes { switch compiler { case "gc": if s := gcSizesFor(compiler, arch); s != nil { return Sizes(s) } case "gccgo": if s, ok := gccgoArchSizes[arch]; ok { return Sizes(s) } } return nil } // stdSizes is used if Config.Sizes == nil. var stdSizes = SizesFor("gc", "amd64") func (conf *Config) alignof(T Type) int64 { f := stdSizes.Alignof if conf.Sizes != nil { f = conf.Sizes.Alignof } if a := f(T); a >= 1 { return a } panic("implementation of alignof returned an alignment < 1") } func (conf *Config) offsetsof(T *Struct) []int64 { var offsets []int64 if T.NumFields() > 0 { // compute offsets on demand f := stdSizes.Offsetsof if conf.Sizes != nil { f = conf.Sizes.Offsetsof } offsets = f(T.fields) // sanity checks if len(offsets) != T.NumFields() { panic("implementation of offsetsof returned the wrong number of offsets") } } return offsets } // offsetof returns the offset of the field specified via // the index sequence relative to T. All embedded fields // must be structs (rather than pointers to structs). // If the offset is too large (because T is too large), // the result is negative. func (conf *Config) offsetof(T Type, index []int) int64 { var offs int64 for _, i := range index { s := under(T).(*Struct) d := conf.offsetsof(s)[i] if d < 0 { return -1 } offs += d if offs < 0 { return -1 } T = s.fields[i].typ } return offs } // sizeof returns the size of T. // If T is too large, the result is negative. func (conf *Config) sizeof(T Type) int64 { f := stdSizes.Sizeof if conf.Sizes != nil { f = conf.Sizes.Sizeof } return f(T) } // align returns the smallest y >= x such that y % a == 0. // a must be within 1 and 8 and it must be a power of 2. // The result may be negative due to overflow. func align(x, a int64) int64 { assert(x >= 0 && 1 <= a && a <= 8 && a&(a-1) == 0) return (x + a - 1) &^ (a - 1) } PK ! ���_' _' initorder.gonu �[��� // Copyright 2014 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 types2 import ( "container/heap" "fmt" . "internal/types/errors" "sort" ) // initOrder computes the Info.InitOrder for package variables. func (check *Checker) initOrder() { // An InitOrder may already have been computed if a package is // built from several calls to (*Checker).Files. Clear it. check.Info.InitOrder = check.Info.InitOrder[:0] // Compute the object dependency graph and initialize // a priority queue with the list of graph nodes. pq := nodeQueue(dependencyGraph(check.objMap)) heap.Init(&pq) const debug = false if debug { fmt.Printf("Computing initialization order for %s\n\n", check.pkg) fmt.Println("Object dependency graph:") for obj, d := range check.objMap { // only print objects that may appear in the dependency graph if obj, _ := obj.(dependency); obj != nil { if len(d.deps) > 0 { fmt.Printf("\t%s depends on\n", obj.Name()) for dep := range d.deps { fmt.Printf("\t\t%s\n", dep.Name()) } } else { fmt.Printf("\t%s has no dependencies\n", obj.Name()) } } } fmt.Println() fmt.Println("Transposed object dependency graph (functions eliminated):") for _, n := range pq { fmt.Printf("\t%s depends on %d nodes\n", n.obj.Name(), n.ndeps) for p := range n.pred { fmt.Printf("\t\t%s is dependent\n", p.obj.Name()) } } fmt.Println() fmt.Println("Processing nodes:") } // Determine initialization order by removing the highest priority node // (the one with the fewest dependencies) and its edges from the graph, // repeatedly, until there are no nodes left. // In a valid Go program, those nodes always have zero dependencies (after // removing all incoming dependencies), otherwise there are initialization // cycles. emitted := make(map[*declInfo]bool) for len(pq) > 0 { // get the next node n := heap.Pop(&pq).(*graphNode) if debug { fmt.Printf("\t%s (src pos %d) depends on %d nodes now\n", n.obj.Name(), n.obj.order(), n.ndeps) } // if n still depends on other nodes, we have a cycle if n.ndeps > 0 { cycle := findPath(check.objMap, n.obj, n.obj, make(map[Object]bool)) // If n.obj is not part of the cycle (e.g., n.obj->b->c->d->c), // cycle will be nil. Don't report anything in that case since // the cycle is reported when the algorithm gets to an object // in the cycle. // Furthermore, once an object in the cycle is encountered, // the cycle will be broken (dependency count will be reduced // below), and so the remaining nodes in the cycle don't trigger // another error (unless they are part of multiple cycles). if cycle != nil { check.reportCycle(cycle) } // Ok to continue, but the variable initialization order // will be incorrect at this point since it assumes no // cycle errors. } // reduce dependency count of all dependent nodes // and update priority queue for p := range n.pred { p.ndeps-- heap.Fix(&pq, p.index) } // record the init order for variables with initializers only v, _ := n.obj.(*Var) info := check.objMap[v] if v == nil || !info.hasInitializer() { continue } // n:1 variable declarations such as: a, b = f() // introduce a node for each lhs variable (here: a, b); // but they all have the same initializer - emit only // one, for the first variable seen if emitted[info] { continue // initializer already emitted, if any } emitted[info] = true infoLhs := info.lhs // possibly nil (see declInfo.lhs field comment) if infoLhs == nil { infoLhs = []*Var{v} } init := &Initializer{infoLhs, info.init} check.Info.InitOrder = append(check.Info.InitOrder, init) } if debug { fmt.Println() fmt.Println("Initialization order:") for _, init := range check.Info.InitOrder { fmt.Printf("\t%s\n", init) } fmt.Println() } } // findPath returns the (reversed) list of objects []Object{to, ... from} // such that there is a path of object dependencies from 'from' to 'to'. // If there is no such path, the result is nil. func findPath(objMap map[Object]*declInfo, from, to Object, seen map[Object]bool) []Object { if seen[from] { return nil } seen[from] = true for d := range objMap[from].deps { if d == to { return []Object{d} } if P := findPath(objMap, d, to, seen); P != nil { return append(P, d) } } return nil } // reportCycle reports an error for the given cycle. func (check *Checker) reportCycle(cycle []Object) { obj := cycle[0] // report a more concise error for self references if len(cycle) == 1 { check.errorf(obj, InvalidInitCycle, "initialization cycle: %s refers to itself", obj.Name()) return } var err error_ err.code = InvalidInitCycle err.errorf(obj, "initialization cycle for %s", obj.Name()) // subtle loop: print cycle[i] for i = 0, n-1, n-2, ... 1 for len(cycle) = n for i := len(cycle) - 1; i >= 0; i-- { err.errorf(obj, "%s refers to", obj.Name()) obj = cycle[i] } // print cycle[0] again to close the cycle err.errorf(obj, "%s", obj.Name()) check.report(&err) } // ---------------------------------------------------------------------------- // Object dependency graph // A dependency is an object that may be a dependency in an initialization // expression. Only constants, variables, and functions can be dependencies. // Constants are here because constant expression cycles are reported during // initialization order computation. type dependency interface { Object isDependency() } // A graphNode represents a node in the object dependency graph. // Each node p in n.pred represents an edge p->n, and each node // s in n.succ represents an edge n->s; with a->b indicating that // a depends on b. type graphNode struct { obj dependency // object represented by this node pred, succ nodeSet // consumers and dependencies of this node (lazily initialized) index int // node index in graph slice/priority queue ndeps int // number of outstanding dependencies before this object can be initialized } // cost returns the cost of removing this node, which involves copying each // predecessor to each successor (and vice-versa). func (n *graphNode) cost() int { return len(n.pred) * len(n.succ) } type nodeSet map[*graphNode]bool func (s *nodeSet) add(p *graphNode) { if *s == nil { *s = make(nodeSet) } (*s)[p] = true } // dependencyGraph computes the object dependency graph from the given objMap, // with any function nodes removed. The resulting graph contains only constants // and variables. func dependencyGraph(objMap map[Object]*declInfo) []*graphNode { // M is the dependency (Object) -> graphNode mapping M := make(map[dependency]*graphNode) for obj := range objMap { // only consider nodes that may be an initialization dependency if obj, _ := obj.(dependency); obj != nil { M[obj] = &graphNode{obj: obj} } } // compute edges for graph M // (We need to include all nodes, even isolated ones, because they still need // to be scheduled for initialization in correct order relative to other nodes.) for obj, n := range M { // for each dependency obj -> d (= deps[i]), create graph edges n->s and s->n for d := range objMap[obj].deps { // only consider nodes that may be an initialization dependency if d, _ := d.(dependency); d != nil { d := M[d] n.succ.add(d) d.pred.add(n) } } } var G, funcG []*graphNode // separate non-functions and functions for _, n := range M { if _, ok := n.obj.(*Func); ok { funcG = append(funcG, n) } else { G = append(G, n) } } // remove function nodes and collect remaining graph nodes in G // (Mutually recursive functions may introduce cycles among themselves // which are permitted. Yet such cycles may incorrectly inflate the dependency // count for variables which in turn may not get scheduled for initialization // in correct order.) // // Note that because we recursively copy predecessors and successors // throughout the function graph, the cost of removing a function at // position X is proportional to cost * (len(funcG)-X). Therefore, we should // remove high-cost functions last. sort.Slice(funcG, func(i, j int) bool { return funcG[i].cost() < funcG[j].cost() }) for _, n := range funcG { // connect each predecessor p of n with each successor s // and drop the function node (don't collect it in G) for p := range n.pred { // ignore self-cycles if p != n { // Each successor s of n becomes a successor of p, and // each predecessor p of n becomes a predecessor of s. for s := range n.succ { // ignore self-cycles if s != n { p.succ.add(s) s.pred.add(p) } } delete(p.succ, n) // remove edge to n } } for s := range n.succ { delete(s.pred, n) // remove edge to n } } // fill in index and ndeps fields for i, n := range G { n.index = i n.ndeps = len(n.succ) } return G } // ---------------------------------------------------------------------------- // Priority queue // nodeQueue implements the container/heap interface; // a nodeQueue may be used as a priority queue. type nodeQueue []*graphNode func (a nodeQueue) Len() int { return len(a) } func (a nodeQueue) Swap(i, j int) { x, y := a[i], a[j] a[i], a[j] = y, x x.index, y.index = j, i } func (a nodeQueue) Less(i, j int) bool { x, y := a[i], a[j] // Prioritize all constants before non-constants. See go.dev/issue/66575/. _, xConst := x.obj.(*Const) _, yConst := y.obj.(*Const) if xConst != yConst { return xConst } // nodes are prioritized by number of incoming dependencies (1st key) // and source order (2nd key) return x.ndeps < y.ndeps || x.ndeps == y.ndeps && x.obj.order() < y.obj.order() } func (a *nodeQueue) Push(x interface{}) { panic("unreachable") } func (a *nodeQueue) Pop() interface{} { n := len(*a) x := (*a)[n-1] x.index = -1 // for safety *a = (*a)[:n-1] return x } PK ! �`� D D api.gonu �[��� // Copyright 2012 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 types declares the data types and implements // the algorithms for type-checking of Go packages. Use // Config.Check to invoke the type checker for a package. // Alternatively, create a new type checker with NewChecker // and invoke it incrementally by calling Checker.Files. // // Type-checking consists of several interdependent phases: // // Name resolution maps each identifier (syntax.Name) in the program to the // language object (Object) it denotes. // Use Info.{Defs,Uses,Implicits} for the results of name resolution. // // Constant folding computes the exact constant value (constant.Value) // for every expression (syntax.Expr) that is a compile-time constant. // Use Info.Types[expr].Value for the results of constant folding. // // Type inference computes the type (Type) of every expression (syntax.Expr) // and checks for compliance with the language specification. // Use Info.Types[expr].Type for the results of type inference. package types2 import ( "cmd/compile/internal/syntax" "fmt" "go/constant" . "internal/types/errors" "strings" ) // An Error describes a type-checking error; it implements the error interface. // A "soft" error is an error that still permits a valid interpretation of a // package (such as "unused variable"); "hard" errors may lead to unpredictable // behavior if ignored. type Error struct { Pos syntax.Pos // error position Msg string // default error message, user-friendly Full string // full error message, for debugging (may contain internal details) Soft bool // if set, error is "soft" Code Code // error code } // Error returns an error string formatted as follows: // filename:line:column: message func (err Error) Error() string { return fmt.Sprintf("%s: %s", err.Pos, err.Msg) } // FullError returns an error string like Error, buy it may contain // type-checker internal details such as subscript indices for type // parameters and more. Useful for debugging. func (err Error) FullError() string { return fmt.Sprintf("%s: %s", err.Pos, err.Full) } // An ArgumentError holds an error associated with an argument index. type ArgumentError struct { Index int Err error } func (e *ArgumentError) Error() string { return e.Err.Error() } func (e *ArgumentError) Unwrap() error { return e.Err } // An Importer resolves import paths to Packages. // // CAUTION: This interface does not support the import of locally // vendored packages. See https://golang.org/s/go15vendor. // If possible, external implementations should implement ImporterFrom. type Importer interface { // Import returns the imported package for the given import path. // The semantics is like for ImporterFrom.ImportFrom except that // dir and mode are ignored (since they are not present). Import(path string) (*Package, error) } // ImportMode is reserved for future use. type ImportMode int // An ImporterFrom resolves import paths to packages; it // supports vendoring per https://golang.org/s/go15vendor. // Use go/importer to obtain an ImporterFrom implementation. type ImporterFrom interface { // Importer is present for backward-compatibility. Calling // Import(path) is the same as calling ImportFrom(path, "", 0); // i.e., locally vendored packages may not be found. // The types package does not call Import if an ImporterFrom // is present. Importer // ImportFrom returns the imported package for the given import // path when imported by a package file located in dir. // If the import failed, besides returning an error, ImportFrom // is encouraged to cache and return a package anyway, if one // was created. This will reduce package inconsistencies and // follow-on type checker errors due to the missing package. // The mode value must be 0; it is reserved for future use. // Two calls to ImportFrom with the same path and dir must // return the same package. ImportFrom(path, dir string, mode ImportMode) (*Package, error) } // A Config specifies the configuration for type checking. // The zero value for Config is a ready-to-use default configuration. type Config struct { // Context is the context used for resolving global identifiers. If nil, the // type checker will initialize this field with a newly created context. Context *Context // GoVersion describes the accepted Go language version. The string must // start with a prefix of the form "go%d.%d" (e.g. "go1.20", "go1.21rc1", or // "go1.21.0") or it must be empty; an empty string disables Go language // version checks. If the format is invalid, invoking the type checker will // result in an error. GoVersion string // If IgnoreFuncBodies is set, function bodies are not // type-checked. IgnoreFuncBodies bool // If FakeImportC is set, `import "C"` (for packages requiring Cgo) // declares an empty "C" package and errors are omitted for qualified // identifiers referring to package C (which won't find an object). // This feature is intended for the standard library cmd/api tool. // // Caution: Effects may be unpredictable due to follow-on errors. // Do not use casually! FakeImportC bool // If IgnoreBranchErrors is set, branch/label errors are ignored. IgnoreBranchErrors bool // If go115UsesCgo is set, the type checker expects the // _cgo_gotypes.go file generated by running cmd/cgo to be // provided as a package source file. Qualified identifiers // referring to package C will be resolved to cgo-provided // declarations within _cgo_gotypes.go. // // It is an error to set both FakeImportC and go115UsesCgo. go115UsesCgo bool // If Trace is set, a debug trace is printed to stdout. Trace bool // If Error != nil, it is called with each error found // during type checking; err has dynamic type Error. // Secondary errors (for instance, to enumerate all types // involved in an invalid recursive type declaration) have // error strings that start with a '\t' character. // If Error == nil, type-checking stops with the first // error found. Error func(err error) // An importer is used to import packages referred to from // import declarations. // If the installed importer implements ImporterFrom, the type // checker calls ImportFrom instead of Import. // The type checker reports an error if an importer is needed // but none was installed. Importer Importer // If Sizes != nil, it provides the sizing functions for package unsafe. // Otherwise SizesFor("gc", "amd64") is used instead. Sizes Sizes // If DisableUnusedImportCheck is set, packages are not checked // for unused imports. DisableUnusedImportCheck bool // If a non-empty ErrorURL format string is provided, it is used // to format an error URL link that is appended to the first line // of an error message. ErrorURL must be a format string containing // exactly one "%s" format, e.g. "[go.dev/e/%s]". ErrorURL string } func srcimporter_setUsesCgo(conf *Config) { conf.go115UsesCgo = true } // Info holds result type information for a type-checked package. // Only the information for which a map is provided is collected. // If the package has type errors, the collected information may // be incomplete. type Info struct { // Types maps expressions to their types, and for constant // expressions, also their values. Invalid expressions are // omitted. // // For (possibly parenthesized) identifiers denoting built-in // functions, the recorded signatures are call-site specific: // if the call result is not a constant, the recorded type is // an argument-specific signature. Otherwise, the recorded type // is invalid. // // The Types map does not record the type of every identifier, // only those that appear where an arbitrary expression is // permitted. For instance, the identifier f in a selector // expression x.f is found only in the Selections map, the // identifier z in a variable declaration 'var z int' is found // only in the Defs map, and identifiers denoting packages in // qualified identifiers are collected in the Uses map. Types map[syntax.Expr]TypeAndValue // If StoreTypesInSyntax is set, type information identical to // that which would be put in the Types map, will be set in // syntax.Expr.TypeAndValue (independently of whether Types // is nil or not). StoreTypesInSyntax bool // Instances maps identifiers denoting generic types or functions to their // type arguments and instantiated type. // // For example, Instances will map the identifier for 'T' in the type // instantiation T[int, string] to the type arguments [int, string] and // resulting instantiated *Named type. Given a generic function // func F[A any](A), Instances will map the identifier for 'F' in the call // expression F(int(1)) to the inferred type arguments [int], and resulting // instantiated *Signature. // // Invariant: Instantiating Uses[id].Type() with Instances[id].TypeArgs // results in an equivalent of Instances[id].Type. Instances map[*syntax.Name]Instance // Defs maps identifiers to the objects they define (including // package names, dots "." of dot-imports, and blank "_" identifiers). // For identifiers that do not denote objects (e.g., the package name // in package clauses, or symbolic variables t in t := x.(type) of // type switch headers), the corresponding objects are nil. // // For an embedded field, Defs returns the field *Var it defines. // // Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos() Defs map[*syntax.Name]Object // Uses maps identifiers to the objects they denote. // // For an embedded field, Uses returns the *TypeName it denotes. // // Invariant: Uses[id].Pos() != id.Pos() Uses map[*syntax.Name]Object // Implicits maps nodes to their implicitly declared objects, if any. // The following node and object types may appear: // // node declared object // // *syntax.ImportDecl *PkgName for imports without renames // *syntax.CaseClause type-specific *Var for each type switch case clause (incl. default) // *syntax.Field anonymous parameter *Var (incl. unnamed results) // Implicits map[syntax.Node]Object // Selections maps selector expressions (excluding qualified identifiers) // to their corresponding selections. Selections map[*syntax.SelectorExpr]*Selection // Scopes maps syntax.Nodes to the scopes they define. Package scopes are not // associated with a specific node but with all files belonging to a package. // Thus, the package scope can be found in the type-checked Package object. // Scopes nest, with the Universe scope being the outermost scope, enclosing // the package scope, which contains (one or more) files scopes, which enclose // function scopes which in turn enclose statement and function literal scopes. // Note that even though package-level functions are declared in the package // scope, the function scopes are embedded in the file scope of the file // containing the function declaration. // // The Scope of a function contains the declarations of any // type parameters, parameters, and named results, plus any // local declarations in the body block. // It is coextensive with the complete extent of the // function's syntax ([*ast.FuncDecl] or [*ast.FuncLit]). // The Scopes mapping does not contain an entry for the // function body ([*ast.BlockStmt]); the function's scope is // associated with the [*ast.FuncType]. // // The following node types may appear in Scopes: // // *syntax.File // *syntax.FuncType // *syntax.TypeDecl // *syntax.BlockStmt // *syntax.IfStmt // *syntax.SwitchStmt // *syntax.CaseClause // *syntax.CommClause // *syntax.ForStmt // Scopes map[syntax.Node]*Scope // InitOrder is the list of package-level initializers in the order in which // they must be executed. Initializers referring to variables related by an // initialization dependency appear in topological order, the others appear // in source order. Variables without an initialization expression do not // appear in this list. InitOrder []*Initializer // FileVersions maps a file to its Go version string. // If the file doesn't specify a version, the reported // string is Config.GoVersion. // Version strings begin with “go”, like “go1.21”, and // are suitable for use with the [go/version] package. FileVersions map[*syntax.PosBase]string } func (info *Info) recordTypes() bool { return info.Types != nil || info.StoreTypesInSyntax } // TypeOf returns the type of expression e, or nil if not found. // Precondition 1: the Types map is populated or StoreTypesInSynax is set. // Precondition 2: Uses and Defs maps are populated. func (info *Info) TypeOf(e syntax.Expr) Type { if info.Types != nil { if t, ok := info.Types[e]; ok { return t.Type } } else if info.StoreTypesInSyntax { if tv := e.GetTypeInfo(); tv.Type != nil { return tv.Type } } if id, _ := e.(*syntax.Name); id != nil { if obj := info.ObjectOf(id); obj != nil { return obj.Type() } } return nil } // ObjectOf returns the object denoted by the specified id, // or nil if not found. // // If id is an embedded struct field, ObjectOf returns the field (*Var) // it defines, not the type (*TypeName) it uses. // // Precondition: the Uses and Defs maps are populated. func (info *Info) ObjectOf(id *syntax.Name) Object { if obj := info.Defs[id]; obj != nil { return obj } return info.Uses[id] } // PkgNameOf returns the local package name defined by the import, // or nil if not found. // // For dot-imports, the package name is ".". // // Precondition: the Defs and Implicts maps are populated. func (info *Info) PkgNameOf(imp *syntax.ImportDecl) *PkgName { var obj Object if imp.LocalPkgName != nil { obj = info.Defs[imp.LocalPkgName] } else { obj = info.Implicits[imp] } pkgname, _ := obj.(*PkgName) return pkgname } // TypeAndValue reports the type and value (for constants) // of the corresponding expression. type TypeAndValue struct { mode operandMode Type Type Value constant.Value } // IsVoid reports whether the corresponding expression // is a function call without results. func (tv TypeAndValue) IsVoid() bool { return tv.mode == novalue } // IsType reports whether the corresponding expression specifies a type. func (tv TypeAndValue) IsType() bool { return tv.mode == typexpr } // IsBuiltin reports whether the corresponding expression denotes // a (possibly parenthesized) built-in function. func (tv TypeAndValue) IsBuiltin() bool { return tv.mode == builtin } // IsValue reports whether the corresponding expression is a value. // Builtins are not considered values. Constant values have a non- // nil Value. func (tv TypeAndValue) IsValue() bool { switch tv.mode { case constant_, variable, mapindex, value, nilvalue, commaok, commaerr: return true } return false } // IsNil reports whether the corresponding expression denotes the // predeclared value nil. Depending on context, it may have been // given a type different from UntypedNil. func (tv TypeAndValue) IsNil() bool { return tv.mode == nilvalue } // Addressable reports whether the corresponding expression // is addressable (https://golang.org/ref/spec#Address_operators). func (tv TypeAndValue) Addressable() bool { return tv.mode == variable } // Assignable reports whether the corresponding expression // is assignable to (provided a value of the right type). func (tv TypeAndValue) Assignable() bool { return tv.mode == variable || tv.mode == mapindex } // HasOk reports whether the corresponding expression may be // used on the rhs of a comma-ok assignment. func (tv TypeAndValue) HasOk() bool { return tv.mode == commaok || tv.mode == mapindex } // Instance reports the type arguments and instantiated type for type and // function instantiations. For type instantiations, Type will be of dynamic // type *Named. For function instantiations, Type will be of dynamic type // *Signature. type Instance struct { TypeArgs *TypeList Type Type } // An Initializer describes a package-level variable, or a list of variables in case // of a multi-valued initialization expression, and the corresponding initialization // expression. type Initializer struct { Lhs []*Var // var Lhs = Rhs Rhs syntax.Expr } func (init *Initializer) String() string { var buf strings.Builder for i, lhs := range init.Lhs { if i > 0 { buf.WriteString(", ") } buf.WriteString(lhs.Name()) } buf.WriteString(" = ") syntax.Fprint(&buf, init.Rhs, syntax.ShortForm) return buf.String() } // Check type-checks a package and returns the resulting package object and // the first error if any. Additionally, if info != nil, Check populates each // of the non-nil maps in the Info struct. // // The package is marked as complete if no errors occurred, otherwise it is // incomplete. See Config.Error for controlling behavior in the presence of // errors. // // The package is specified by a list of *syntax.Files and corresponding // file set, and the package path the package is identified with. // The clean path must not be empty or dot ("."). func (conf *Config) Check(path string, files []*syntax.File, info *Info) (*Package, error) { pkg := NewPackage(path, "") return pkg, NewChecker(conf, pkg, info).Files(files) } PK ! �ٕ� � mono_test.gonu �[��� // Copyright 2021 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 types2_test import ( "cmd/compile/internal/types2" "errors" "fmt" "strings" "testing" ) func checkMono(t *testing.T, body string) error { src := "package x; import `unsafe`; var _ unsafe.Pointer;\n" + body var buf strings.Builder conf := types2.Config{ Error: func(err error) { fmt.Fprintln(&buf, err) }, Importer: defaultImporter(), } typecheck(src, &conf, nil) if buf.Len() == 0 { return nil } return errors.New(strings.TrimRight(buf.String(), "\n")) } func TestMonoGood(t *testing.T) { for i, good := range goods { if err := checkMono(t, good); err != nil { t.Errorf("%d: unexpected failure: %v", i, err) } } } func TestMonoBad(t *testing.T) { for i, bad := range bads { if err := checkMono(t, bad); err == nil { t.Errorf("%d: unexpected success", i) } else { t.Log(err) } } } var goods = []string{ "func F[T any](x T) { F(x) }", "func F[T, U, V any]() { F[U, V, T](); F[V, T, U]() }", "type Ring[A, B, C any] struct { L *Ring[B, C, A]; R *Ring[C, A, B] }", "func F[T any]() { type U[T any] [unsafe.Sizeof(F[*T])]byte }", "func F[T any]() { type U[T any] [unsafe.Sizeof(F[*T])]byte; var _ U[int] }", "type U[T any] [unsafe.Sizeof(F[*T])]byte; func F[T any]() { var _ U[U[int]] }", "func F[T any]() { type A = int; F[A]() }", } // TODO(mdempsky): Validate specific error messages and positioning. var bads = []string{ "func F[T any](x T) { F(&x) }", "func F[T any]() { F[*T]() }", "func F[T any]() { F[[]T]() }", "func F[T any]() { F[[1]T]() }", "func F[T any]() { F[chan T]() }", "func F[T any]() { F[map[*T]int]() }", "func F[T any]() { F[map[error]T]() }", "func F[T any]() { F[func(T)]() }", "func F[T any]() { F[func() T]() }", "func F[T any]() { F[struct{ t T }]() }", "func F[T any]() { F[interface{ t() T }]() }", "type U[_ any] int; func F[T any]() { F[U[T]]() }", "func F[T any]() { type U int; F[U]() }", "func F[T any]() { type U int; F[*U]() }", "type U[T any] int; func (U[T]) m() { var _ U[*T] }", "type U[T any] int; func (*U[T]) m() { var _ U[*T] }", "type U[T1 any] [unsafe.Sizeof(F[*T1])]byte; func F[T2 any]() { var _ U[T2] }", "func F[A, B, C, D, E any]() { F[B, C, D, E, *A]() }", "type U[_ any] int; const X = unsafe.Sizeof(func() { type A[T any] U[A[*T]] })", "func F[T any]() { type A = *T; F[A]() }", "type A[T any] struct { _ A[*T] }", } PK ! E��- �- index.gonu �[��� // Copyright 2021 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. // This file implements typechecking of index/slice expressions. package types2 import ( "cmd/compile/internal/syntax" "go/constant" . "internal/types/errors" ) // If e is a valid function instantiation, indexExpr returns true. // In that case x represents the uninstantiated function value and // it is the caller's responsibility to instantiate the function. func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst bool) { check.exprOrType(x, e.X, true) // x may be generic switch x.mode { case invalid: check.use(e.Index) return false case typexpr: // type instantiation x.mode = invalid // TODO(gri) here we re-evaluate e.X - try to avoid this x.typ = check.varType(e) if isValid(x.typ) { x.mode = typexpr } return false case value: if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { // function instantiation return true } } // x should not be generic at this point, but be safe and check check.nonGeneric(nil, x) if x.mode == invalid { return false } // ordinary index expression valid := false length := int64(-1) // valid if >= 0 switch typ := under(x.typ).(type) { case *Basic: if isString(typ) { valid = true if x.mode == constant_ { length = int64(len(constant.StringVal(x.val))) } // an indexed string always yields a byte value // (not a constant) even if the string and the // index are constant x.mode = value x.typ = universeByte // use 'byte' name } case *Array: valid = true length = typ.len if x.mode != variable { x.mode = value } x.typ = typ.elem case *Pointer: if typ, _ := under(typ.base).(*Array); typ != nil { valid = true length = typ.len x.mode = variable x.typ = typ.elem } case *Slice: valid = true x.mode = variable x.typ = typ.elem case *Map: index := check.singleIndex(e) if index == nil { x.mode = invalid return false } var key operand check.expr(nil, &key, index) check.assignment(&key, typ.key, "map index") // ok to continue even if indexing failed - map element type is known x.mode = mapindex x.typ = typ.elem x.expr = e return false case *Interface: if !isTypeParam(x.typ) { break } // TODO(gri) report detailed failure cause for better error messages var key, elem Type // key != nil: we must have all maps mode := variable // non-maps result mode // TODO(gri) factor out closure and use it for non-typeparam cases as well if typ.typeSet().underIs(func(u Type) bool { l := int64(-1) // valid if >= 0 var k, e Type // k is only set for maps switch t := u.(type) { case *Basic: if isString(t) { e = universeByte mode = value } case *Array: l = t.len e = t.elem if x.mode != variable { mode = value } case *Pointer: if t, _ := under(t.base).(*Array); t != nil { l = t.len e = t.elem } case *Slice: e = t.elem case *Map: k = t.key e = t.elem } if e == nil { return false } if elem == nil { // first type length = l key, elem = k, e return true } // all map keys must be identical (incl. all nil) // (that is, we cannot mix maps with other types) if !Identical(key, k) { return false } // all element types must be identical if !Identical(elem, e) { return false } // track the minimal length for arrays, if any if l >= 0 && l < length { length = l } return true }) { // For maps, the index expression must be assignable to the map key type. if key != nil { index := check.singleIndex(e) if index == nil { x.mode = invalid return false } var k operand check.expr(nil, &k, index) check.assignment(&k, key, "map index") // ok to continue even if indexing failed - map element type is known x.mode = mapindex x.typ = elem x.expr = e return false } // no maps valid = true x.mode = mode x.typ = elem } } if !valid { check.errorf(e.Pos(), NonSliceableOperand, invalidOp+"cannot index %s", x) check.use(e.Index) x.mode = invalid return false } index := check.singleIndex(e) if index == nil { x.mode = invalid return false } // In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0) // the element type may be accessed before it's set. Make sure we have // a valid type. if x.typ == nil { x.typ = Typ[Invalid] } check.index(index, length) return false } func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) { check.expr(nil, x, e.X) if x.mode == invalid { check.use(e.Index[:]...) return } valid := false length := int64(-1) // valid if >= 0 switch u := coreString(x.typ).(type) { case nil: check.errorf(x, NonSliceableOperand, invalidOp+"cannot slice %s: %s has no core type", x, x.typ) x.mode = invalid return case *Basic: if isString(u) { if e.Full { at := e.Index[2] if at == nil { at = e // e.Index[2] should be present but be careful } check.error(at, InvalidSliceExpr, invalidOp+"3-index slice of string") x.mode = invalid return } valid = true if x.mode == constant_ { length = int64(len(constant.StringVal(x.val))) } // spec: "For untyped string operands the result // is a non-constant value of type string." if isUntyped(x.typ) { x.typ = Typ[String] } } case *Array: valid = true length = u.len if x.mode != variable { check.errorf(x, NonSliceableOperand, invalidOp+"%s (slice of unaddressable value)", x) x.mode = invalid return } x.typ = &Slice{elem: u.elem} case *Pointer: if u, _ := under(u.base).(*Array); u != nil { valid = true length = u.len x.typ = &Slice{elem: u.elem} } case *Slice: valid = true // x.typ doesn't change } if !valid { check.errorf(x, NonSliceableOperand, invalidOp+"cannot slice %s", x) x.mode = invalid return } x.mode = value // spec: "Only the first index may be omitted; it defaults to 0." if e.Full && (e.Index[1] == nil || e.Index[2] == nil) { check.error(e, InvalidSyntaxTree, "2nd and 3rd index required in 3-index slice") x.mode = invalid return } // check indices var ind [3]int64 for i, expr := range e.Index { x := int64(-1) switch { case expr != nil: // The "capacity" is only known statically for strings, arrays, // and pointers to arrays, and it is the same as the length for // those types. max := int64(-1) if length >= 0 { max = length + 1 } if _, v := check.index(expr, max); v >= 0 { x = v } case i == 0: // default is 0 for the first index x = 0 case length >= 0: // default is length (== capacity) otherwise x = length } ind[i] = x } // constant indices must be in range // (check.index already checks that existing indices >= 0) L: for i, x := range ind[:len(ind)-1] { if x > 0 { for j, y := range ind[i+1:] { if y >= 0 && y < x { // The value y corresponds to the expression e.Index[i+1+j]. // Because y >= 0, it must have been set from the expression // when checking indices and thus e.Index[i+1+j] is not nil. check.errorf(e.Index[i+1+j], SwappedSliceIndices, "invalid slice indices: %d < %d", y, x) break L // only report one error, ok to continue } } } } } // singleIndex returns the (single) index from the index expression e. // If the index is missing, or if there are multiple indices, an error // is reported and the result is nil. func (check *Checker) singleIndex(e *syntax.IndexExpr) syntax.Expr { index := e.Index if index == nil { check.errorf(e, InvalidSyntaxTree, "missing index for %s", e.X) return nil } if l, _ := index.(*syntax.ListExpr); l != nil { if n := len(l.ElemList); n <= 1 { check.errorf(e, InvalidSyntaxTree, "invalid use of ListExpr for index expression %v with %d indices", e, n) return nil } // len(l.ElemList) > 1 check.error(l.ElemList[1], InvalidIndex, invalidOp+"more than one index") index = l.ElemList[0] // continue with first index } return index } // index checks an index expression for validity. // If max >= 0, it is the upper bound for index. // If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type. // If the result val >= 0, index is valid and val is its constant int value. func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64) { typ = Typ[Invalid] val = -1 var x operand check.expr(nil, &x, index) if !check.isValidIndex(&x, InvalidIndex, "index", false) { return } if x.mode != constant_ { return x.typ, -1 } if x.val.Kind() == constant.Unknown { return } v, ok := constant.Int64Val(x.val) assert(ok) if max >= 0 && v >= max { check.errorf(&x, InvalidIndex, invalidArg+"index %s out of bounds [0:%d]", x.val.String(), max) return } // 0 <= v [ && v < max ] return x.typ, v } // isValidIndex checks whether operand x satisfies the criteria for integer // index values. If allowNegative is set, a constant operand may be negative. // If the operand is not valid, an error is reported (using what as context) // and the result is false. func (check *Checker) isValidIndex(x *operand, code Code, what string, allowNegative bool) bool { if x.mode == invalid { return false } // spec: "a constant index that is untyped is given type int" check.convertUntyped(x, Typ[Int]) if x.mode == invalid { return false } // spec: "the index x must be of integer type or an untyped constant" if !allInteger(x.typ) { check.errorf(x, code, invalidArg+"%s %s must be integer", what, x) return false } if x.mode == constant_ { // spec: "a constant index must be non-negative ..." if !allowNegative && constant.Sign(x.val) < 0 { check.errorf(x, code, invalidArg+"%s %s must not be negative", what, x) return false } // spec: "... and representable by a value of type int" if !representableConst(x.val, check, Typ[Int], &x.val) { check.errorf(x, code, invalidArg+"%s %s overflows int", what, x) return false } } return true } // indexedElts checks the elements (elts) of an array or slice composite literal // against the literal's element type (typ), and the element indices against // the literal length if known (length >= 0). It returns the length of the // literal (maximum index value + 1). func (check *Checker) indexedElts(elts []syntax.Expr, typ Type, length int64) int64 { visited := make(map[int64]bool, len(elts)) var index, max int64 for _, e := range elts { // determine and check index validIndex := false eval := e if kv, _ := e.(*syntax.KeyValueExpr); kv != nil { if typ, i := check.index(kv.Key, length); isValid(typ) { if i >= 0 { index = i validIndex = true } else { check.errorf(e, InvalidLitIndex, "index %s must be integer constant", kv.Key) } } eval = kv.Value } else if length >= 0 && index >= length { check.errorf(e, OversizeArrayLit, "index %d is out of bounds (>= %d)", index, length) } else { validIndex = true } // if we have a valid index, check for duplicate entries if validIndex { if visited[index] { check.errorf(e, DuplicateLitKey, "duplicate index %d in array or slice literal", index) } visited[index] = true } index++ if index > max { max = index } // check element against composite literal element type var x operand check.exprWithHint(&x, eval, typ) check.assignment(&x, typ, "array or slice literal") } return max } PK ! �� errors_test.gonu �[��� // Copyright 2020 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 types2 import "testing" func TestError(t *testing.T) { var err error_ want := "no error" if got := err.String(); got != want { t.Errorf("empty error: got %q, want %q", got, want) } want = "<unknown position>: foo 42" err.errorf(nopos, "foo %d", 42) if got := err.String(); got != want { t.Errorf("simple error: got %q, want %q", got, want) } want = "<unknown position>: foo 42\n\tbar 43" err.errorf(nopos, "bar %d", 43) if got := err.String(); got != want { t.Errorf("simple error: got %q, want %q", got, want) } } func TestStripAnnotations(t *testing.T) { for _, test := range []struct { in, want string }{ {"", ""}, {" ", " "}, {"foo", "foo"}, {"foo₀", "foo"}, {"foo(T₀)", "foo(T)"}, } { got := stripAnnotations(test.in) if got != test.want { t.Errorf("%q: got %q; want %q", test.in, got, test.want) } } } PK ! s֝� termlist.gonu �[��� // Copyright 2021 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 types2 import "strings" // A termlist represents the type set represented by the union // t1 ∪ y2 ∪ ... tn of the type sets of the terms t1 to tn. // A termlist is in normal form if all terms are disjoint. // termlist operations don't require the operands to be in // normal form. type termlist []*term // allTermlist represents the set of all types. // It is in normal form. var allTermlist = termlist{new(term)} // termSep is the separator used between individual terms. const termSep = " | " // String prints the termlist exactly (without normalization). func (xl termlist) String() string { if len(xl) == 0 { return "∅" } var buf strings.Builder for i, x := range xl { if i > 0 { buf.WriteString(termSep) } buf.WriteString(x.String()) } return buf.String() } // isEmpty reports whether the termlist xl represents the empty set of types. func (xl termlist) isEmpty() bool { // If there's a non-nil term, the entire list is not empty. // If the termlist is in normal form, this requires at most // one iteration. for _, x := range xl { if x != nil { return false } } return true } // isAll reports whether the termlist xl represents the set of all types. func (xl termlist) isAll() bool { // If there's a 𝓤 term, the entire list is 𝓤. // If the termlist is in normal form, this requires at most // one iteration. for _, x := range xl { if x != nil && x.typ == nil { return true } } return false } // norm returns the normal form of xl. func (xl termlist) norm() termlist { // Quadratic algorithm, but good enough for now. // TODO(gri) fix asymptotic performance used := make([]bool, len(xl)) var rl termlist for i, xi := range xl { if xi == nil || used[i] { continue } for j := i + 1; j < len(xl); j++ { xj := xl[j] if xj == nil || used[j] { continue } if u1, u2 := xi.union(xj); u2 == nil { // If we encounter a 𝓤 term, the entire list is 𝓤. // Exit early. // (Note that this is not just an optimization; // if we continue, we may end up with a 𝓤 term // and other terms and the result would not be // in normal form.) if u1.typ == nil { return allTermlist } xi = u1 used[j] = true // xj is now unioned into xi - ignore it in future iterations } } rl = append(rl, xi) } return rl } // union returns the union xl ∪ yl. func (xl termlist) union(yl termlist) termlist { return append(xl, yl...).norm() } // intersect returns the intersection xl ∩ yl. func (xl termlist) intersect(yl termlist) termlist { if xl.isEmpty() || yl.isEmpty() { return nil } // Quadratic algorithm, but good enough for now. // TODO(gri) fix asymptotic performance var rl termlist for _, x := range xl { for _, y := range yl { if r := x.intersect(y); r != nil { rl = append(rl, r) } } } return rl.norm() } // equal reports whether xl and yl represent the same type set. func (xl termlist) equal(yl termlist) bool { // TODO(gri) this should be more efficient return xl.subsetOf(yl) && yl.subsetOf(xl) } // includes reports whether t ∈ xl. func (xl termlist) includes(t Type) bool { for _, x := range xl { if x.includes(t) { return true } } return false } // supersetOf reports whether y ⊆ xl. func (xl termlist) supersetOf(y *term) bool { for _, x := range xl { if y.subsetOf(x) { return true } } return false } // subsetOf reports whether xl ⊆ yl. func (xl termlist) subsetOf(yl termlist) bool { if yl.isEmpty() { return xl.isEmpty() } // each term x of xl must be a subset of yl for _, x := range xl { if !yl.supersetOf(x) { return false // x is not a subset yl } } return true } PK ! ����% �% scope.gonu �[��� // Copyright 2013 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. // This file implements Scopes. package types2 import ( "cmd/compile/internal/syntax" "fmt" "io" "sort" "strings" "sync" ) // A Scope maintains a set of objects and links to its containing // (parent) and contained (children) scopes. Objects may be inserted // and looked up by name. The zero value for Scope is a ready-to-use // empty scope. type Scope struct { parent *Scope children []*Scope number int // parent.children[number-1] is this scope; 0 if there is no parent elems map[string]Object // lazily allocated pos, end syntax.Pos // scope extent; may be invalid comment string // for debugging only isFunc bool // set if this is a function scope (internal use only) } // NewScope returns a new, empty scope contained in the given parent // scope, if any. The comment is for debugging only. func NewScope(parent *Scope, pos, end syntax.Pos, comment string) *Scope { s := &Scope{parent, nil, 0, nil, pos, end, comment, false} // don't add children to Universe scope! if parent != nil && parent != Universe { parent.children = append(parent.children, s) s.number = len(parent.children) } return s } // Parent returns the scope's containing (parent) scope. func (s *Scope) Parent() *Scope { return s.parent } // Len returns the number of scope elements. func (s *Scope) Len() int { return len(s.elems) } // Names returns the scope's element names in sorted order. func (s *Scope) Names() []string { names := make([]string, len(s.elems)) i := 0 for name := range s.elems { names[i] = name i++ } sort.Strings(names) return names } // NumChildren returns the number of scopes nested in s. func (s *Scope) NumChildren() int { return len(s.children) } // Child returns the i'th child scope for 0 <= i < NumChildren(). func (s *Scope) Child(i int) *Scope { return s.children[i] } // Lookup returns the object in scope s with the given name if such an // object exists; otherwise the result is nil. func (s *Scope) Lookup(name string) Object { return resolve(name, s.elems[name]) } // LookupParent follows the parent chain of scopes starting with s until // it finds a scope where Lookup(name) returns a non-nil object, and then // returns that scope and object. If a valid position pos is provided, // only objects that were declared at or before pos are considered. // If no such scope and object exists, the result is (nil, nil). // // Note that obj.Parent() may be different from the returned scope if the // object was inserted into the scope and already had a parent at that // time (see Insert). This can only happen for dot-imported objects // whose scope is the scope of the package that exported them. func (s *Scope) LookupParent(name string, pos syntax.Pos) (*Scope, Object) { for ; s != nil; s = s.parent { if obj := s.Lookup(name); obj != nil && (!pos.IsKnown() || cmpPos(obj.scopePos(), pos) <= 0) { return s, obj } } return nil, nil } // Insert attempts to insert an object obj into scope s. // If s already contains an alternative object alt with // the same name, Insert leaves s unchanged and returns alt. // Otherwise it inserts obj, sets the object's parent scope // if not already set, and returns nil. func (s *Scope) Insert(obj Object) Object { name := obj.Name() if alt := s.Lookup(name); alt != nil { return alt } s.insert(name, obj) if obj.Parent() == nil { obj.setParent(s) } return nil } // InsertLazy is like Insert, but allows deferring construction of the // inserted object until it's accessed with Lookup. The Object // returned by resolve must have the same name as given to InsertLazy. // If s already contains an alternative object with the same name, // InsertLazy leaves s unchanged and returns false. Otherwise it // records the binding and returns true. The object's parent scope // will be set to s after resolve is called. func (s *Scope) InsertLazy(name string, resolve func() Object) bool { if s.elems[name] != nil { return false } s.insert(name, &lazyObject{parent: s, resolve: resolve}) return true } func (s *Scope) insert(name string, obj Object) { if s.elems == nil { s.elems = make(map[string]Object) } s.elems[name] = obj } // Squash merges s with its parent scope p by adding all // objects of s to p, adding all children of s to the // children of p, and removing s from p's children. // The function f is called for each object obj in s which // has an object alt in p. s should be discarded after // having been squashed. func (s *Scope) Squash(err func(obj, alt Object)) { p := s.parent assert(p != nil) for name, obj := range s.elems { obj = resolve(name, obj) obj.setParent(nil) if alt := p.Insert(obj); alt != nil { err(obj, alt) } } j := -1 // index of s in p.children for i, ch := range p.children { if ch == s { j = i break } } assert(j >= 0) k := len(p.children) - 1 p.children[j] = p.children[k] p.children = p.children[:k] p.children = append(p.children, s.children...) s.children = nil s.elems = nil } // Pos and End describe the scope's source code extent [pos, end). // The results are guaranteed to be valid only if the type-checked // AST has complete position information. The extent is undefined // for Universe and package scopes. func (s *Scope) Pos() syntax.Pos { return s.pos } func (s *Scope) End() syntax.Pos { return s.end } // Contains reports whether pos is within the scope's extent. // The result is guaranteed to be valid only if the type-checked // AST has complete position information. func (s *Scope) Contains(pos syntax.Pos) bool { return cmpPos(s.pos, pos) <= 0 && cmpPos(pos, s.end) < 0 } // Innermost returns the innermost (child) scope containing // pos. If pos is not within any scope, the result is nil. // The result is also nil for the Universe scope. // The result is guaranteed to be valid only if the type-checked // AST has complete position information. func (s *Scope) Innermost(pos syntax.Pos) *Scope { // Package scopes do not have extents since they may be // discontiguous, so iterate over the package's files. if s.parent == Universe { for _, s := range s.children { if inner := s.Innermost(pos); inner != nil { return inner } } } if s.Contains(pos) { for _, s := range s.children { if s.Contains(pos) { return s.Innermost(pos) } } return s } return nil } // WriteTo writes a string representation of the scope to w, // with the scope elements sorted by name. // The level of indentation is controlled by n >= 0, with // n == 0 for no indentation. // If recurse is set, it also writes nested (children) scopes. func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) { const ind = ". " indn := strings.Repeat(ind, n) fmt.Fprintf(w, "%s%s scope %p {\n", indn, s.comment, s) indn1 := indn + ind for _, name := range s.Names() { fmt.Fprintf(w, "%s%s\n", indn1, s.Lookup(name)) } if recurse { for _, s := range s.children { s.WriteTo(w, n+1, recurse) } } fmt.Fprintf(w, "%s}\n", indn) } // String returns a string representation of the scope, for debugging. func (s *Scope) String() string { var buf strings.Builder s.WriteTo(&buf, 0, false) return buf.String() } // A lazyObject represents an imported Object that has not been fully // resolved yet by its importer. type lazyObject struct { parent *Scope resolve func() Object obj Object once sync.Once } // resolve returns the Object represented by obj, resolving lazy // objects as appropriate. func resolve(name string, obj Object) Object { if lazy, ok := obj.(*lazyObject); ok { lazy.once.Do(func() { obj := lazy.resolve() if _, ok := obj.(*lazyObject); ok { panic("recursive lazy object") } if obj.Name() != name { panic("lazy object has unexpected name") } if obj.Parent() == nil { obj.setParent(lazy.parent) } lazy.obj = obj }) obj = lazy.obj } return obj } // stub implementations so *lazyObject implements Object and we can // store them directly into Scope.elems. func (*lazyObject) Parent() *Scope { panic("unreachable") } func (*lazyObject) Pos() syntax.Pos { panic("unreachable") } func (*lazyObject) Pkg() *Package { panic("unreachable") } func (*lazyObject) Name() string { panic("unreachable") } func (*lazyObject) Type() Type { panic("unreachable") } func (*lazyObject) Exported() bool { panic("unreachable") } func (*lazyObject) Id() string { panic("unreachable") } func (*lazyObject) String() string { panic("unreachable") } func (*lazyObject) order() uint32 { panic("unreachable") } func (*lazyObject) color() color { panic("unreachable") } func (*lazyObject) setType(Type) { panic("unreachable") } func (*lazyObject) setOrder(uint32) { panic("unreachable") } func (*lazyObject) setColor(color color) { panic("unreachable") } func (*lazyObject) setParent(*Scope) { panic("unreachable") } func (*lazyObject) sameId(pkg *Package, name string) bool { panic("unreachable") } func (*lazyObject) scopePos() syntax.Pos { panic("unreachable") } func (*lazyObject) setScopePos(pos syntax.Pos) { panic("unreachable") } PK ! ��Pv v example_test.gonu �[��� // Copyright 2015 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. // Only run where builders (build.golang.org) have // access to compiled packages for import. // //go:build !android && !ios && !js && !wasip1 package types2_test // This file shows examples of basic usage of the go/types API. // // To locate a Go package, use (*go/build.Context).Import. // To load, parse, and type-check a complete Go program // from source, use golang.org/x/tools/go/loader. import ( "cmd/compile/internal/syntax" "cmd/compile/internal/types2" "fmt" "log" "regexp" "sort" "strings" ) // ExampleScope prints the tree of Scopes of a package created from a // set of parsed files. func ExampleScope() { // Parse the source files for a package. var files []*syntax.File for _, src := range []string{ `package main import "fmt" func main() { freezing := FToC(-18) fmt.Println(freezing, Boiling) } `, `package main import "fmt" type Celsius float64 func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) } func FToC(f float64) Celsius { return Celsius(f - 32 / 9 * 5) } const Boiling Celsius = 100 func Unused() { {}; {{ var x int; _ = x }} } // make sure empty block scopes get printed `, } { files = append(files, mustParse(src)) } // Type-check a package consisting of these files. // Type information for the imported "fmt" package // comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a. conf := types2.Config{Importer: defaultImporter()} pkg, err := conf.Check("temperature", files, nil) if err != nil { log.Fatal(err) } // Print the tree of scopes. // For determinism, we redact addresses. var buf strings.Builder pkg.Scope().WriteTo(&buf, 0, true) rx := regexp.MustCompile(` 0x[a-fA-F0-9]*`) fmt.Println(rx.ReplaceAllString(buf.String(), "")) // Output: // package "temperature" scope { // . const temperature.Boiling temperature.Celsius // . type temperature.Celsius float64 // . func temperature.FToC(f float64) temperature.Celsius // . func temperature.Unused() // . func temperature.main() // . main scope { // . . package fmt // . . function scope { // . . . var freezing temperature.Celsius // . . } // . } // . main scope { // . . package fmt // . . function scope { // . . . var c temperature.Celsius // . . } // . . function scope { // . . . var f float64 // . . } // . . function scope { // . . . block scope { // . . . } // . . . block scope { // . . . . block scope { // . . . . . var x int // . . . . } // . . . } // . . } // . } // } } // ExampleInfo prints various facts recorded by the type checker in a // types2.Info struct: definitions of and references to each named object, // and the type, value, and mode of every expression in the package. func ExampleInfo() { // Parse a single source file. const input = ` package fib type S string var a, b, c = len(b), S(c), "hello" func fib(x int) int { if x < 2 { return x } return fib(x-1) - fib(x-2) }` // Type-check the package. // We create an empty map for each kind of input // we're interested in, and Check populates them. info := types2.Info{ Types: make(map[syntax.Expr]types2.TypeAndValue), Defs: make(map[*syntax.Name]types2.Object), Uses: make(map[*syntax.Name]types2.Object), } pkg := mustTypecheck(input, nil, &info) // Print package-level variables in initialization order. fmt.Printf("InitOrder: %v\n\n", info.InitOrder) // For each named object, print the line and // column of its definition and each of its uses. fmt.Println("Defs and Uses of each named object:") usesByObj := make(map[types2.Object][]string) for id, obj := range info.Uses { posn := id.Pos() lineCol := fmt.Sprintf("%d:%d", posn.Line(), posn.Col()) usesByObj[obj] = append(usesByObj[obj], lineCol) } var items []string for obj, uses := range usesByObj { sort.Strings(uses) item := fmt.Sprintf("%s:\n defined at %s\n used at %s", types2.ObjectString(obj, types2.RelativeTo(pkg)), obj.Pos(), strings.Join(uses, ", ")) items = append(items, item) } sort.Strings(items) // sort by line:col, in effect fmt.Println(strings.Join(items, "\n")) fmt.Println() // TODO(gri) Enable once positions are updated/verified // fmt.Println("Types and Values of each expression:") // items = nil // for expr, tv := range info.Types { // var buf strings.Builder // posn := expr.Pos() // tvstr := tv.Type.String() // if tv.Value != nil { // tvstr += " = " + tv.Value.String() // } // // line:col | expr | mode : type = value // fmt.Fprintf(&buf, "%2d:%2d | %-19s | %-7s : %s", // posn.Line(), posn.Col(), types2.ExprString(expr), // mode(tv), tvstr) // items = append(items, buf.String()) // } // sort.Strings(items) // fmt.Println(strings.Join(items, "\n")) // Output: // InitOrder: [c = "hello" b = S(c) a = len(b)] // // Defs and Uses of each named object: // builtin len: // defined at <unknown position> // used at 6:15 // func fib(x int) int: // defined at fib:8:6 // used at 12:20, 12:9 // type S string: // defined at fib:4:6 // used at 6:23 // type int: // defined at <unknown position> // used at 8:12, 8:17 // type string: // defined at <unknown position> // used at 4:8 // var b S: // defined at fib:6:8 // used at 6:19 // var c string: // defined at fib:6:11 // used at 6:25 // var x int: // defined at fib:8:10 // used at 10:10, 12:13, 12:24, 9:5 } // TODO(gri) Enable once positions are updated/verified // Types and Values of each expression: // 4: 8 | string | type : string // 6:15 | len | builtin : func(string) int // 6:15 | len(b) | value : int // 6:19 | b | var : fib.S // 6:23 | S | type : fib.S // 6:23 | S(c) | value : fib.S // 6:25 | c | var : string // 6:29 | "hello" | value : string = "hello" // 8:12 | int | type : int // 8:17 | int | type : int // 9: 5 | x | var : int // 9: 5 | x < 2 | value : untyped bool // 9: 9 | 2 | value : int = 2 // 10:10 | x | var : int // 12: 9 | fib | value : func(x int) int // 12: 9 | fib(x - 1) | value : int // 12: 9 | fib(x - 1) - fib(x - 2) | value : int // 12:13 | x | var : int // 12:13 | x - 1 | value : int // 12:15 | 1 | value : int = 1 // 12:20 | fib | value : func(x int) int // 12:20 | fib(x - 2) | value : int // 12:24 | x | var : int // 12:24 | x - 2 | value : int // 12:26 | 2 | value : int = 2 func mode(tv types2.TypeAndValue) string { switch { case tv.IsVoid(): return "void" case tv.IsType(): return "type" case tv.IsBuiltin(): return "builtin" case tv.IsNil(): return "nil" case tv.Assignable(): if tv.Addressable() { return "var" } return "mapindex" case tv.IsValue(): return "value" default: return "unknown" } } PK ! �g��# # array.gonu �[��� // Copyright 2011 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 types2 // An Array represents an array type. type Array struct { len int64 elem Type } // NewArray returns a new array type for the given element type and length. // A negative length indicates an unknown length. func NewArray(elem Type, len int64) *Array { return &Array{len: len, elem: elem} } // Len returns the length of array a. // A negative result indicates an unknown length. func (a *Array) Len() int64 { return a.len } // Elem returns element type of array a. func (a *Array) Elem() Type { return a.elem } func (a *Array) Underlying() Type { return a } func (a *Array) String() string { return TypeString(a, nil) } PK ! P'� < < type.gonu �[��� // Copyright 2011 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 types2 import "cmd/compile/internal/syntax" // A Type represents a type of Go. // All types implement the Type interface. type Type = syntax.Type PK ! g(��� � map.gonu �[��� // Copyright 2011 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 types2 // A Map represents a map type. type Map struct { key, elem Type } // NewMap returns a new map for the given key and element types. func NewMap(key, elem Type) *Map { return &Map{key: key, elem: elem} } // Key returns the key type of map m. func (m *Map) Key() Type { return m.key } // Elem returns the element type of map m. func (m *Map) Elem() Type { return m.elem } func (t *Map) Underlying() Type { return t } func (t *Map) String() string { return TypeString(t, nil) } PK ! �����6 �6 check_test.gonu �[��� // Copyright 2011 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. // This file implements a typechecker test harness. The packages specified // in tests are typechecked. Error messages reported by the typechecker are // compared against the errors expected in the test files. // // Expected errors are indicated in the test files by putting comments // of the form /* ERROR pattern */ or /* ERRORx pattern */ (or a similar // //-style line comment) immediately following the tokens where errors // are reported. There must be exactly one blank before and after the // ERROR/ERRORx indicator, and the pattern must be a properly quoted Go // string. // // The harness will verify that each ERROR pattern is a substring of the // error reported at that source position, and that each ERRORx pattern // is a regular expression matching the respective error. // Consecutive comments may be used to indicate multiple errors reported // at the same position. // // For instance, the following test source indicates that an "undeclared" // error should be reported for the undeclared variable x: // // package p // func f() { // _ = x /* ERROR "undeclared" */ + 1 // } package types2_test import ( "bytes" "cmd/compile/internal/syntax" "flag" "fmt" "internal/buildcfg" "internal/testenv" "os" "path/filepath" "reflect" "regexp" "runtime" "strconv" "strings" "testing" . "cmd/compile/internal/types2" ) var ( haltOnError = flag.Bool("halt", false, "halt on error") verifyErrors = flag.Bool("verify", false, "verify errors (rather than list them) in TestManual") ) func parseFiles(t *testing.T, filenames []string, srcs [][]byte, mode syntax.Mode) ([]*syntax.File, []error) { var files []*syntax.File var errlist []error errh := func(err error) { errlist = append(errlist, err) } for i, filename := range filenames { base := syntax.NewFileBase(filename) r := bytes.NewReader(srcs[i]) file, err := syntax.Parse(base, r, errh, nil, mode) if file == nil { t.Fatalf("%s: %s", filename, err) } files = append(files, file) } return files, errlist } func unpackError(err error) (syntax.Pos, string) { switch err := err.(type) { case syntax.Error: return err.Pos, err.Msg case Error: return err.Pos, err.Msg default: return nopos, err.Error() } } // absDiff returns the absolute difference between x and y. func absDiff(x, y uint) uint { if x < y { return y - x } return x - y } // parseFlags parses flags from the first line of the given source if the line // starts with "//" (line comment) followed by "-" (possibly with spaces // between). Otherwise the line is ignored. func parseFlags(src []byte, flags *flag.FlagSet) error { // we must have a line comment that starts with a "-" const prefix = "//" if !bytes.HasPrefix(src, []byte(prefix)) { return nil // first line is not a line comment } src = src[len(prefix):] if i := bytes.Index(src, []byte("-")); i < 0 || len(bytes.TrimSpace(src[:i])) != 0 { return nil // comment doesn't start with a "-" } end := bytes.Index(src, []byte("\n")) const maxLen = 256 if end < 0 || end > maxLen { return fmt.Errorf("flags comment line too long") } return flags.Parse(strings.Fields(string(src[:end]))) } // testFiles type-checks the package consisting of the given files, and // compares the resulting errors with the ERROR annotations in the source. // Except for manual tests, each package is type-checked twice, once without // use of Alias types, and once with Alias types. // // The srcs slice contains the file content for the files named in the // filenames slice. The colDelta parameter specifies the tolerance for position // mismatch when comparing errors. The manual parameter specifies whether this // is a 'manual' test. // // If provided, opts may be used to mutate the Config before type-checking. func testFiles(t *testing.T, filenames []string, srcs [][]byte, colDelta uint, manual bool, opts ...func(*Config)) { // Alias types are disabled by default testFilesImpl(t, filenames, srcs, colDelta, manual, opts...) if !manual { t.Setenv("GODEBUG", "gotypesalias=1") testFilesImpl(t, filenames, srcs, colDelta, manual, opts...) } } func testFilesImpl(t *testing.T, filenames []string, srcs [][]byte, colDelta uint, manual bool, opts ...func(*Config)) { if len(filenames) == 0 { t.Fatal("no source files") } // parse files files, errlist := parseFiles(t, filenames, srcs, 0) pkgName := "<no package>" if len(files) > 0 { pkgName = files[0].PkgName.Value } listErrors := manual && !*verifyErrors if listErrors && len(errlist) > 0 { t.Errorf("--- %s:", pkgName) for _, err := range errlist { t.Error(err) } } // set up typechecker var conf Config conf.Trace = manual && testing.Verbose() conf.Importer = defaultImporter() conf.Error = func(err error) { if *haltOnError { defer panic(err) } if listErrors { t.Error(err) return } errlist = append(errlist, err) } // apply custom configuration for _, opt := range opts { opt(&conf) } // apply flag setting (overrides custom configuration) var goexperiment, gotypesalias string flags := flag.NewFlagSet("", flag.PanicOnError) flags.StringVar(&conf.GoVersion, "lang", "", "") flags.StringVar(&goexperiment, "goexperiment", "", "") flags.BoolVar(&conf.FakeImportC, "fakeImportC", false, "") flags.StringVar(&gotypesalias, "gotypesalias", "", "") if err := parseFlags(srcs[0], flags); err != nil { t.Fatal(err) } exp, err := buildcfg.ParseGOEXPERIMENT(runtime.GOOS, runtime.GOARCH, goexperiment) if err != nil { t.Fatal(err) } old := buildcfg.Experiment defer func() { buildcfg.Experiment = old }() buildcfg.Experiment = *exp // By default, gotypesalias is not set. if gotypesalias != "" { t.Setenv("GODEBUG", "gotypesalias="+gotypesalias) } // Provide Config.Info with all maps so that info recording is tested. info := Info{ Types: make(map[syntax.Expr]TypeAndValue), Instances: make(map[*syntax.Name]Instance), Defs: make(map[*syntax.Name]Object), Uses: make(map[*syntax.Name]Object), Implicits: make(map[syntax.Node]Object), Selections: make(map[*syntax.SelectorExpr]*Selection), Scopes: make(map[syntax.Node]*Scope), FileVersions: make(map[*syntax.PosBase]string), } // typecheck conf.Check(pkgName, files, &info) if listErrors { return } // collect expected errors errmap := make(map[string]map[uint][]syntax.Error) for i, filename := range filenames { if m := syntax.CommentMap(bytes.NewReader(srcs[i]), regexp.MustCompile("^ ERRORx? ")); len(m) > 0 { errmap[filename] = m } } // match against found errors var indices []int // list indices of matching errors, reused for each error for _, err := range errlist { gotPos, gotMsg := unpackError(err) // find list of errors for the respective error line filename := gotPos.Base().Filename() filemap := errmap[filename] line := gotPos.Line() var errList []syntax.Error if filemap != nil { errList = filemap[line] } // At least one of the errors in errList should match the current error. indices = indices[:0] for i, want := range errList { pattern, substr := strings.CutPrefix(want.Msg, " ERROR ") if !substr { var found bool pattern, found = strings.CutPrefix(want.Msg, " ERRORx ") if !found { panic("unreachable") } } pattern, err := strconv.Unquote(strings.TrimSpace(pattern)) if err != nil { t.Errorf("%s:%d:%d: %v", filename, line, want.Pos.Col(), err) continue } if substr { if !strings.Contains(gotMsg, pattern) { continue } } else { rx, err := regexp.Compile(pattern) if err != nil { t.Errorf("%s:%d:%d: %v", filename, line, want.Pos.Col(), err) continue } if !rx.MatchString(gotMsg) { continue } } indices = append(indices, i) } if len(indices) == 0 { t.Errorf("%s: no error expected: %q", gotPos, gotMsg) continue } // len(indices) > 0 // If there are multiple matching errors, select the one with the closest column position. index := -1 // index of matching error var delta uint for _, i := range indices { if d := absDiff(gotPos.Col(), errList[i].Pos.Col()); index < 0 || d < delta { index, delta = i, d } } // The closest column position must be within expected colDelta. if delta > colDelta { t.Errorf("%s: got col = %d; want %d", gotPos, gotPos.Col(), errList[index].Pos.Col()) } // eliminate from errList if n := len(errList) - 1; n > 0 { // not the last entry - slide entries down (don't reorder) copy(errList[index:], errList[index+1:]) filemap[line] = errList[:n] } else { // last entry - remove errList from filemap delete(filemap, line) } // if filemap is empty, eliminate from errmap if len(filemap) == 0 { delete(errmap, filename) } } // there should be no expected errors left if len(errmap) > 0 { t.Errorf("--- %s: unreported errors:", pkgName) for filename, filemap := range errmap { for line, errList := range filemap { for _, err := range errList { t.Errorf("%s:%d:%d: %s", filename, line, err.Pos.Col(), err.Msg) } } } } } // boolFieldAddr(conf, name) returns the address of the boolean field conf.<name>. // For accessing unexported fields. func boolFieldAddr(conf *Config, name string) *bool { v := reflect.Indirect(reflect.ValueOf(conf)) return (*bool)(v.FieldByName(name).Addr().UnsafePointer()) } // TestManual is for manual testing of a package - either provided // as a list of filenames belonging to the package, or a directory // name containing the package files - after the test arguments // (and a separating "--"). For instance, to test the package made // of the files foo.go and bar.go, use: // // go test -run Manual -- foo.go bar.go // // If no source arguments are provided, the file testdata/manual.go // is used instead. // Provide the -verify flag to verify errors against ERROR comments // in the input files rather than having a list of errors reported. // The accepted Go language version can be controlled with the -lang // flag. func TestManual(t *testing.T) { testenv.MustHaveGoBuild(t) filenames := flag.Args() if len(filenames) == 0 { filenames = []string{filepath.FromSlash("testdata/manual.go")} } info, err := os.Stat(filenames[0]) if err != nil { t.Fatalf("TestManual: %v", err) } DefPredeclaredTestFuncs() if info.IsDir() { if len(filenames) > 1 { t.Fatal("TestManual: must have only one directory argument") } testDir(t, filenames[0], 0, true) } else { testPkg(t, filenames, 0, true) } } func TestLongConstants(t *testing.T) { format := `package longconst; const _ = %s /* ERROR "constant overflow" */; const _ = %s // ERROR "excessively long constant"` src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001)) testFiles(t, []string{"longconst.go"}, [][]byte{[]byte(src)}, 0, false) } func withSizes(sizes Sizes) func(*Config) { return func(cfg *Config) { cfg.Sizes = sizes } } // TestIndexRepresentability tests that constant index operands must // be representable as int even if they already have a type that can // represent larger values. func TestIndexRepresentability(t *testing.T) { const src = `package index; var s []byte; var _ = s[int64 /* ERRORx "int64\\(1\\) << 40 \\(.*\\) overflows int" */ (1) << 40]` testFiles(t, []string{"index.go"}, [][]byte{[]byte(src)}, 0, false, withSizes(&StdSizes{4, 4})) } func TestIssue47243_TypedRHS(t *testing.T) { // The RHS of the shift expression below overflows uint on 32bit platforms, // but this is OK as it is explicitly typed. const src = `package issue47243; var a uint64; var _ = a << uint64(4294967296)` // uint64(1<<32) testFiles(t, []string{"p.go"}, [][]byte{[]byte(src)}, 0, false, withSizes(&StdSizes{4, 4})) } func TestCheck(t *testing.T) { old := buildcfg.Experiment.RangeFunc defer func() { buildcfg.Experiment.RangeFunc = old }() buildcfg.Experiment.RangeFunc = true DefPredeclaredTestFuncs() testDirFiles(t, "../../../../internal/types/testdata/check", 50, false) // TODO(gri) narrow column tolerance } func TestSpec(t *testing.T) { testDirFiles(t, "../../../../internal/types/testdata/spec", 0, false) } func TestExamples(t *testing.T) { testDirFiles(t, "../../../../internal/types/testdata/examples", 125, false) } // TODO(gri) narrow column tolerance func TestFixedbugs(t *testing.T) { testDirFiles(t, "../../../../internal/types/testdata/fixedbugs", 100, false) } // TODO(gri) narrow column tolerance func TestLocal(t *testing.T) { testDirFiles(t, "testdata/local", 0, false) } func testDirFiles(t *testing.T, dir string, colDelta uint, manual bool) { testenv.MustHaveGoBuild(t) dir = filepath.FromSlash(dir) fis, err := os.ReadDir(dir) if err != nil { t.Error(err) return } for _, fi := range fis { path := filepath.Join(dir, fi.Name()) // If fi is a directory, its files make up a single package. if fi.IsDir() { testDir(t, path, colDelta, manual) } else { t.Run(filepath.Base(path), func(t *testing.T) { testPkg(t, []string{path}, colDelta, manual) }) } } } func testDir(t *testing.T, dir string, colDelta uint, manual bool) { fis, err := os.ReadDir(dir) if err != nil { t.Error(err) return } var filenames []string for _, fi := range fis { filenames = append(filenames, filepath.Join(dir, fi.Name())) } t.Run(filepath.Base(dir), func(t *testing.T) { testPkg(t, filenames, colDelta, manual) }) } func testPkg(t *testing.T, filenames []string, colDelta uint, manual bool) { srcs := make([][]byte, len(filenames)) for i, filename := range filenames { src, err := os.ReadFile(filename) if err != nil { t.Fatalf("could not read %s: %v", filename, err) } srcs[i] = src } testFiles(t, filenames, srcs, colDelta, manual) } PK ! G��.g5 g5 typeset.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" "sort" "strings" ) // ---------------------------------------------------------------------------- // API // A _TypeSet represents the type set of an interface. // Because of existing language restrictions, methods can be "factored out" // from the terms. The actual type set is the intersection of the type set // implied by the methods and the type set described by the terms and the // comparable bit. To test whether a type is included in a type set // ("implements" relation), the type must implement all methods _and_ be // an element of the type set described by the terms and the comparable bit. // If the term list describes the set of all types and comparable is true, // only comparable types are meant; in all other cases comparable is false. type _TypeSet struct { methods []*Func // all methods of the interface; sorted by unique ID terms termlist // type terms of the type set comparable bool // invariant: !comparable || terms.isAll() } // IsEmpty reports whether type set s is the empty set. func (s *_TypeSet) IsEmpty() bool { return s.terms.isEmpty() } // IsAll reports whether type set s is the set of all types (corresponding to the empty interface). func (s *_TypeSet) IsAll() bool { return s.IsMethodSet() && len(s.methods) == 0 } // IsMethodSet reports whether the interface t is fully described by its method set. func (s *_TypeSet) IsMethodSet() bool { return !s.comparable && s.terms.isAll() } // IsComparable reports whether each type in the set is comparable. func (s *_TypeSet) IsComparable(seen map[Type]bool) bool { if s.terms.isAll() { return s.comparable } return s.is(func(t *term) bool { return t != nil && comparable(t.typ, false, seen, nil) }) } // NumMethods returns the number of methods available. func (s *_TypeSet) NumMethods() int { return len(s.methods) } // Method returns the i'th method of type set s for 0 <= i < s.NumMethods(). // The methods are ordered by their unique ID. func (s *_TypeSet) Method(i int) *Func { return s.methods[i] } // LookupMethod returns the index of and method with matching package and name, or (-1, nil). func (s *_TypeSet) LookupMethod(pkg *Package, name string, foldCase bool) (int, *Func) { return lookupMethod(s.methods, pkg, name, foldCase) } func (s *_TypeSet) String() string { switch { case s.IsEmpty(): return "∅" case s.IsAll(): return "𝓤" } hasMethods := len(s.methods) > 0 hasTerms := s.hasTerms() var buf strings.Builder buf.WriteByte('{') if s.comparable { buf.WriteString("comparable") if hasMethods || hasTerms { buf.WriteString("; ") } } for i, m := range s.methods { if i > 0 { buf.WriteString("; ") } buf.WriteString(m.String()) } if hasMethods && hasTerms { buf.WriteString("; ") } if hasTerms { buf.WriteString(s.terms.String()) } buf.WriteString("}") return buf.String() } // ---------------------------------------------------------------------------- // Implementation // hasTerms reports whether the type set has specific type terms. func (s *_TypeSet) hasTerms() bool { return !s.terms.isEmpty() && !s.terms.isAll() } // subsetOf reports whether s1 ⊆ s2. func (s1 *_TypeSet) subsetOf(s2 *_TypeSet) bool { return s1.terms.subsetOf(s2.terms) } // TODO(gri) TypeSet.is and TypeSet.underIs should probably also go into termlist.go // is calls f with the specific type terms of s and reports whether // all calls to f returned true. If there are no specific terms, is // returns the result of f(nil). func (s *_TypeSet) is(f func(*term) bool) bool { if !s.hasTerms() { return f(nil) } for _, t := range s.terms { assert(t.typ != nil) if !f(t) { return false } } return true } // underIs calls f with the underlying types of the specific type terms // of s and reports whether all calls to f returned true. If there are // no specific terms, underIs returns the result of f(nil). func (s *_TypeSet) underIs(f func(Type) bool) bool { if !s.hasTerms() { return f(nil) } for _, t := range s.terms { assert(t.typ != nil) // x == under(x) for ~x terms u := t.typ if !t.tilde { u = under(u) } if debug { assert(Identical(u, under(u))) } if !f(u) { return false } } return true } // topTypeSet may be used as type set for the empty interface. var topTypeSet = _TypeSet{terms: allTermlist} // computeInterfaceTypeSet may be called with check == nil. func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_TypeSet { if ityp.tset != nil { return ityp.tset } // If the interface is not fully set up yet, the type set will // not be complete, which may lead to errors when using the // type set (e.g. missing method). Don't compute a partial type // set (and don't store it!), so that we still compute the full // type set eventually. Instead, return the top type set and // let any follow-on errors play out. if !ityp.complete { return &topTypeSet } if check != nil && check.conf.Trace { // Types don't generally have position information. // If we don't have a valid pos provided, try to use // one close enough. if !pos.IsKnown() && len(ityp.methods) > 0 { pos = ityp.methods[0].pos } check.trace(pos, "-- type set for %s", ityp) check.indent++ defer func() { check.indent-- check.trace(pos, "=> %s ", ityp.typeSet()) }() } // An infinitely expanding interface (due to a cycle) is detected // elsewhere (Checker.validType), so here we simply assume we only // have valid interfaces. Mark the interface as complete to avoid // infinite recursion if the validType check occurs later for some // reason. ityp.tset = &_TypeSet{terms: allTermlist} // TODO(gri) is this sufficient? var unionSets map[*Union]*_TypeSet if check != nil { if check.unionTypeSets == nil { check.unionTypeSets = make(map[*Union]*_TypeSet) } unionSets = check.unionTypeSets } else { unionSets = make(map[*Union]*_TypeSet) } // Methods of embedded interfaces are collected unchanged; i.e., the identity // of a method I.m's Func Object of an interface I is the same as that of // the method m in an interface that embeds interface I. On the other hand, // if a method is embedded via multiple overlapping embedded interfaces, we // don't provide a guarantee which "original m" got chosen for the embedding // interface. See also go.dev/issue/34421. // // If we don't care to provide this identity guarantee anymore, instead of // reusing the original method in embeddings, we can clone the method's Func // Object and give it the position of a corresponding embedded interface. Then // we can get rid of the mpos map below and simply use the cloned method's // position. var seen objset var allMethods []*Func mpos := make(map[*Func]syntax.Pos) // method specification or method embedding position, for good error messages addMethod := func(pos syntax.Pos, m *Func, explicit bool) { switch other := seen.insert(m); { case other == nil: allMethods = append(allMethods, m) mpos[m] = pos case explicit: if check != nil { var err error_ err.code = DuplicateDecl err.errorf(pos, "duplicate method %s", m.name) err.errorf(mpos[other.(*Func)], "other declaration of %s", m.name) check.report(&err) } default: // We have a duplicate method name in an embedded (not explicitly declared) method. // Check method signatures after all types are computed (go.dev/issue/33656). // If we're pre-go1.14 (overlapping embeddings are not permitted), report that // error here as well (even though we could do it eagerly) because it's the same // error message. if check != nil { check.later(func() { if !check.allowVersion(m.pkg, pos, go1_14) || !Identical(m.typ, other.Type()) { var err error_ err.code = DuplicateDecl err.errorf(pos, "duplicate method %s", m.name) err.errorf(mpos[other.(*Func)], "other declaration of %s", m.name) check.report(&err) } }).describef(pos, "duplicate method check for %s", m.name) } } } for _, m := range ityp.methods { addMethod(m.pos, m, true) } // collect embedded elements allTerms := allTermlist allComparable := false for i, typ := range ityp.embeddeds { // The embedding position is nil for imported interfaces // and also for interface copies after substitution (but // in that case we don't need to report errors again). var pos syntax.Pos // embedding position if ityp.embedPos != nil { pos = (*ityp.embedPos)[i] } var comparable bool var terms termlist switch u := under(typ).(type) { case *Interface: // For now we don't permit type parameters as constraints. assert(!isTypeParam(typ)) tset := computeInterfaceTypeSet(check, pos, u) // If typ is local, an error was already reported where typ is specified/defined. if check != nil && check.isImportedConstraint(typ) && !check.verifyVersionf(pos, go1_18, "embedding constraint interface %s", typ) { continue } comparable = tset.comparable for _, m := range tset.methods { addMethod(pos, m, false) // use embedding position pos rather than m.pos } terms = tset.terms case *Union: if check != nil && !check.verifyVersionf(pos, go1_18, "embedding interface element %s", u) { continue } tset := computeUnionTypeSet(check, unionSets, pos, u) if tset == &invalidTypeSet { continue // ignore invalid unions } assert(!tset.comparable) assert(len(tset.methods) == 0) terms = tset.terms default: if !isValid(u) { continue } if check != nil && !check.verifyVersionf(pos, go1_18, "embedding non-interface type %s", typ) { continue } terms = termlist{{false, typ}} } // The type set of an interface is the intersection of the type sets of all its elements. // Due to language restrictions, only embedded interfaces can add methods, they are handled // separately. Here we only need to intersect the term lists and comparable bits. allTerms, allComparable = intersectTermLists(allTerms, allComparable, terms, comparable) } ityp.tset.comparable = allComparable if len(allMethods) != 0 { sortMethods(allMethods) ityp.tset.methods = allMethods } ityp.tset.terms = allTerms return ityp.tset } // TODO(gri) The intersectTermLists function belongs to the termlist implementation. // The comparable type set may also be best represented as a term (using // a special type). // intersectTermLists computes the intersection of two term lists and respective comparable bits. // xcomp, ycomp are valid only if xterms.isAll() and yterms.isAll() respectively. func intersectTermLists(xterms termlist, xcomp bool, yterms termlist, ycomp bool) (termlist, bool) { terms := xterms.intersect(yterms) // If one of xterms or yterms is marked as comparable, // the result must only include comparable types. comp := xcomp || ycomp if comp && !terms.isAll() { // only keep comparable terms i := 0 for _, t := range terms { assert(t.typ != nil) if comparable(t.typ, false /* strictly comparable */, nil, nil) { terms[i] = t i++ } } terms = terms[:i] if !terms.isAll() { comp = false } } assert(!comp || terms.isAll()) // comparable invariant return terms, comp } func sortMethods(list []*Func) { sort.Sort(byUniqueMethodName(list)) } func assertSortedMethods(list []*Func) { if !debug { panic("assertSortedMethods called outside debug mode") } if !sort.IsSorted(byUniqueMethodName(list)) { panic("methods not sorted") } } // byUniqueMethodName method lists can be sorted by their unique method names. type byUniqueMethodName []*Func func (a byUniqueMethodName) Len() int { return len(a) } func (a byUniqueMethodName) Less(i, j int) bool { return a[i].less(&a[j].object) } func (a byUniqueMethodName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } // invalidTypeSet is a singleton type set to signal an invalid type set // due to an error. It's also a valid empty type set, so consumers of // type sets may choose to ignore it. var invalidTypeSet _TypeSet // computeUnionTypeSet may be called with check == nil. // The result is &invalidTypeSet if the union overflows. func computeUnionTypeSet(check *Checker, unionSets map[*Union]*_TypeSet, pos syntax.Pos, utyp *Union) *_TypeSet { if tset, _ := unionSets[utyp]; tset != nil { return tset } // avoid infinite recursion (see also computeInterfaceTypeSet) unionSets[utyp] = new(_TypeSet) var allTerms termlist for _, t := range utyp.terms { var terms termlist u := under(t.typ) if ui, _ := u.(*Interface); ui != nil { // For now we don't permit type parameters as constraints. assert(!isTypeParam(t.typ)) terms = computeInterfaceTypeSet(check, pos, ui).terms } else if !isValid(u) { continue } else { if t.tilde && !Identical(t.typ, u) { // There is no underlying type which is t.typ. // The corresponding type set is empty. t = nil // ∅ term } terms = termlist{(*term)(t)} } // The type set of a union expression is the union // of the type sets of each term. allTerms = allTerms.union(terms) if len(allTerms) > maxTermCount { if check != nil { check.errorf(pos, InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) } unionSets[utyp] = &invalidTypeSet return unionSets[utyp] } } unionSets[utyp].terms = allTerms return unionSets[utyp] } PK ! o �� � under.gonu �[��� // Copyright 2011 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 types2 // under returns the true expanded underlying type. // If it doesn't exist, the result is Typ[Invalid]. // under must only be called when a type is known // to be fully set up. func under(t Type) Type { if t := asNamed(t); t != nil { return t.under() } return t.Underlying() } // If t is not a type parameter, coreType returns the underlying type. // If t is a type parameter, coreType returns the single underlying // type of all types in its type set if it exists, or nil otherwise. If the // type set contains only unrestricted and restricted channel types (with // identical element types), the single underlying type is the restricted // channel type if the restrictions are always the same, or nil otherwise. func coreType(t Type) Type { tpar, _ := t.(*TypeParam) if tpar == nil { return under(t) } var su Type if tpar.underIs(func(u Type) bool { if u == nil { return false } if su != nil { u = match(su, u) if u == nil { return false } } // su == nil || match(su, u) != nil su = u return true }) { return su } return nil } // coreString is like coreType but also considers []byte // and strings as identical. In this case, if successful and we saw // a string, the result is of type (possibly untyped) string. func coreString(t Type) Type { tpar, _ := t.(*TypeParam) if tpar == nil { return under(t) // string or untyped string } var su Type hasString := false if tpar.underIs(func(u Type) bool { if u == nil { return false } if isString(u) { u = NewSlice(universeByte) hasString = true } if su != nil { u = match(su, u) if u == nil { return false } } // su == nil || match(su, u) != nil su = u return true }) { if hasString { return Typ[String] } return su } return nil } // If x and y are identical, match returns x. // If x and y are identical channels but for their direction // and one of them is unrestricted, match returns the channel // with the restricted direction. // In all other cases, match returns nil. func match(x, y Type) Type { // Common case: we don't have channels. if Identical(x, y) { return x } // We may have channels that differ in direction only. if x, _ := x.(*Chan); x != nil { if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) { // We have channels that differ in direction only. // If there's an unrestricted channel, select the restricted one. switch { case x.dir == SendRecv: return y case y.dir == SendRecv: return x } } } // types are different return nil } PK ! kM i i return.gonu �[��� // Copyright 2013 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. // This file implements isTerminating. package types2 import ( "cmd/compile/internal/syntax" ) // isTerminating reports if s is a terminating statement. // If s is labeled, label is the label name; otherwise s // is "". func (check *Checker) isTerminating(s syntax.Stmt, label string) bool { switch s := s.(type) { default: unreachable() case *syntax.DeclStmt, *syntax.EmptyStmt, *syntax.SendStmt, *syntax.AssignStmt, *syntax.CallStmt: // no chance case *syntax.LabeledStmt: return check.isTerminating(s.Stmt, s.Label.Value) case *syntax.ExprStmt: // calling the predeclared (possibly parenthesized) panic() function is terminating if call, ok := syntax.Unparen(s.X).(*syntax.CallExpr); ok && check.isPanic[call] { return true } case *syntax.ReturnStmt: return true case *syntax.BranchStmt: if s.Tok == syntax.Goto || s.Tok == syntax.Fallthrough { return true } case *syntax.BlockStmt: return check.isTerminatingList(s.List, "") case *syntax.IfStmt: if s.Else != nil && check.isTerminating(s.Then, "") && check.isTerminating(s.Else, "") { return true } case *syntax.SwitchStmt: return check.isTerminatingSwitch(s.Body, label) case *syntax.SelectStmt: for _, cc := range s.Body { if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) { return false } } return true case *syntax.ForStmt: if _, ok := s.Init.(*syntax.RangeClause); ok { // Range clauses guarantee that the loop terminates, // so the loop is not a terminating statement. See go.dev/issue/49003. break } if s.Cond == nil && !hasBreak(s.Body, label, true) { return true } } return false } func (check *Checker) isTerminatingList(list []syntax.Stmt, label string) bool { // trailing empty statements are permitted - skip them for i := len(list) - 1; i >= 0; i-- { if _, ok := list[i].(*syntax.EmptyStmt); !ok { return check.isTerminating(list[i], label) } } return false // all statements are empty } func (check *Checker) isTerminatingSwitch(body []*syntax.CaseClause, label string) bool { hasDefault := false for _, cc := range body { if cc.Cases == nil { hasDefault = true } if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) { return false } } return hasDefault } // TODO(gri) For nested breakable statements, the current implementation of hasBreak // will traverse the same subtree repeatedly, once for each label. Replace // with a single-pass label/break matching phase. // hasBreak reports if s is or contains a break statement // referring to the label-ed statement or implicit-ly the // closest outer breakable statement. func hasBreak(s syntax.Stmt, label string, implicit bool) bool { switch s := s.(type) { default: unreachable() case *syntax.DeclStmt, *syntax.EmptyStmt, *syntax.ExprStmt, *syntax.SendStmt, *syntax.AssignStmt, *syntax.CallStmt, *syntax.ReturnStmt: // no chance case *syntax.LabeledStmt: return hasBreak(s.Stmt, label, implicit) case *syntax.BranchStmt: if s.Tok == syntax.Break { if s.Label == nil { return implicit } if s.Label.Value == label { return true } } case *syntax.BlockStmt: return hasBreakList(s.List, label, implicit) case *syntax.IfStmt: if hasBreak(s.Then, label, implicit) || s.Else != nil && hasBreak(s.Else, label, implicit) { return true } case *syntax.SwitchStmt: if label != "" && hasBreakCaseList(s.Body, label, false) { return true } case *syntax.SelectStmt: if label != "" && hasBreakCommList(s.Body, label, false) { return true } case *syntax.ForStmt: if label != "" && hasBreak(s.Body, label, false) { return true } } return false } func hasBreakList(list []syntax.Stmt, label string, implicit bool) bool { for _, s := range list { if hasBreak(s, label, implicit) { return true } } return false } func hasBreakCaseList(list []*syntax.CaseClause, label string, implicit bool) bool { for _, s := range list { if hasBreakList(s.Body, label, implicit) { return true } } return false } func hasBreakCommList(list []*syntax.CommClause, label string, implicit bool) bool { for _, s := range list { if hasBreakList(s.Body, label, implicit) { return true } } return false } PK ! �0�z �z stmt.gonu �[��� // Copyright 2012 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. // This file implements typechecking of statements. package types2 import ( "cmd/compile/internal/syntax" "go/constant" "internal/buildcfg" . "internal/types/errors" "sort" ) func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *syntax.BlockStmt, iota constant.Value) { if check.conf.IgnoreFuncBodies { panic("function body not ignored") } if check.conf.Trace { check.trace(body.Pos(), "-- %s: %s", name, sig) } // save/restore current environment and set up function environment // (and use 0 indentation at function start) defer func(env environment, indent int) { check.environment = env check.indent = indent }(check.environment, check.indent) check.environment = environment{ decl: decl, scope: sig.scope, iota: iota, sig: sig, } check.indent = 0 check.stmtList(0, body.List) if check.hasLabel && !check.conf.IgnoreBranchErrors { check.labels(body) } if sig.results.Len() > 0 && !check.isTerminating(body, "") { check.error(body.Rbrace, MissingReturn, "missing return") } // spec: "Implementation restriction: A compiler may make it illegal to // declare a variable inside a function body if the variable is never used." check.usage(sig.scope) } func (check *Checker) usage(scope *Scope) { var unused []*Var for name, elem := range scope.elems { elem = resolve(name, elem) if v, _ := elem.(*Var); v != nil && !v.used { unused = append(unused, v) } } sort.Slice(unused, func(i, j int) bool { return cmpPos(unused[i].pos, unused[j].pos) < 0 }) for _, v := range unused { check.softErrorf(v.pos, UnusedVar, "%s declared and not used", v.name) } for _, scope := range scope.children { // Don't go inside function literal scopes a second time; // they are handled explicitly by funcBody. if !scope.isFunc { check.usage(scope) } } } // stmtContext is a bitset describing which // control-flow statements are permissible, // and provides additional context information // for better error messages. type stmtContext uint const ( // permissible control-flow statements breakOk stmtContext = 1 << iota continueOk fallthroughOk // additional context information finalSwitchCase inTypeSwitch ) func (check *Checker) simpleStmt(s syntax.Stmt) { if s != nil { check.stmt(0, s) } } func trimTrailingEmptyStmts(list []syntax.Stmt) []syntax.Stmt { for i := len(list); i > 0; i-- { if _, ok := list[i-1].(*syntax.EmptyStmt); !ok { return list[:i] } } return nil } func (check *Checker) stmtList(ctxt stmtContext, list []syntax.Stmt) { ok := ctxt&fallthroughOk != 0 inner := ctxt &^ fallthroughOk list = trimTrailingEmptyStmts(list) // trailing empty statements are "invisible" to fallthrough analysis for i, s := range list { inner := inner if ok && i+1 == len(list) { inner |= fallthroughOk } check.stmt(inner, s) } } func (check *Checker) multipleSwitchDefaults(list []*syntax.CaseClause) { var first *syntax.CaseClause for _, c := range list { if c.Cases == nil { if first != nil { check.errorf(c, DuplicateDefault, "multiple defaults (first at %s)", first.Pos()) // TODO(gri) probably ok to bail out after first error (and simplify this code) } else { first = c } } } } func (check *Checker) multipleSelectDefaults(list []*syntax.CommClause) { var first *syntax.CommClause for _, c := range list { if c.Comm == nil { if first != nil { check.errorf(c, DuplicateDefault, "multiple defaults (first at %s)", first.Pos()) // TODO(gri) probably ok to bail out after first error (and simplify this code) } else { first = c } } } } func (check *Checker) openScope(node syntax.Node, comment string) { check.openScopeUntil(node, syntax.EndPos(node), comment) } func (check *Checker) openScopeUntil(node syntax.Node, end syntax.Pos, comment string) { scope := NewScope(check.scope, node.Pos(), end, comment) check.recordScope(node, scope) check.scope = scope } func (check *Checker) closeScope() { check.scope = check.scope.Parent() } func (check *Checker) suspendedCall(keyword string, call syntax.Expr) { code := InvalidDefer if keyword == "go" { code = InvalidGo } if _, ok := call.(*syntax.CallExpr); !ok { check.errorf(call, code, "expression in %s must be function call", keyword) check.use(call) return } var x operand var msg string switch check.rawExpr(nil, &x, call, nil, false) { case conversion: msg = "requires function call, not conversion" case expression: msg = "discards result of" code = UnusedResults case statement: return default: unreachable() } check.errorf(&x, code, "%s %s %s", keyword, msg, &x) } // goVal returns the Go value for val, or nil. func goVal(val constant.Value) interface{} { // val should exist, but be conservative and check if val == nil { return nil } // Match implementation restriction of other compilers. // gc only checks duplicates for integer, floating-point // and string values, so only create Go values for these // types. switch val.Kind() { case constant.Int: if x, ok := constant.Int64Val(val); ok { return x } if x, ok := constant.Uint64Val(val); ok { return x } case constant.Float: if x, ok := constant.Float64Val(val); ok { return x } case constant.String: return constant.StringVal(val) } return nil } // A valueMap maps a case value (of a basic Go type) to a list of positions // where the same case value appeared, together with the corresponding case // types. // Since two case values may have the same "underlying" value but different // types we need to also check the value's types (e.g., byte(1) vs myByte(1)) // when the switch expression is of interface type. type ( valueMap map[interface{}][]valueType // underlying Go value -> valueType valueType struct { pos syntax.Pos typ Type } ) func (check *Checker) caseValues(x *operand, values []syntax.Expr, seen valueMap) { L: for _, e := range values { var v operand check.expr(nil, &v, e) if x.mode == invalid || v.mode == invalid { continue L } check.convertUntyped(&v, x.typ) if v.mode == invalid { continue L } // Order matters: By comparing v against x, error positions are at the case values. res := v // keep original v unchanged check.comparison(&res, x, syntax.Eql, true) if res.mode == invalid { continue L } if v.mode != constant_ { continue L // we're done } // look for duplicate values if val := goVal(v.val); val != nil { // look for duplicate types for a given value // (quadratic algorithm, but these lists tend to be very short) for _, vt := range seen[val] { if Identical(v.typ, vt.typ) { var err error_ err.code = DuplicateCase err.errorf(&v, "duplicate case %s in expression switch", &v) err.errorf(vt.pos, "previous case") check.report(&err) continue L } } seen[val] = append(seen[val], valueType{v.Pos(), v.typ}) } } } // isNil reports whether the expression e denotes the predeclared value nil. func (check *Checker) isNil(e syntax.Expr) bool { // The only way to express the nil value is by literally writing nil (possibly in parentheses). if name, _ := syntax.Unparen(e).(*syntax.Name); name != nil { _, ok := check.lookup(name.Value).(*Nil) return ok } return false } // If the type switch expression is invalid, x is nil. func (check *Checker) caseTypes(x *operand, types []syntax.Expr, seen map[Type]syntax.Expr) (T Type) { var dummy operand L: for _, e := range types { // The spec allows the value nil instead of a type. if check.isNil(e) { T = nil check.expr(nil, &dummy, e) // run e through expr so we get the usual Info recordings } else { T = check.varType(e) if !isValid(T) { continue L } } // look for duplicate types // (quadratic algorithm, but type switches tend to be reasonably small) for t, other := range seen { if T == nil && t == nil || T != nil && t != nil && Identical(T, t) { // talk about "case" rather than "type" because of nil case Ts := "nil" if T != nil { Ts = TypeString(T, check.qualifier) } var err error_ err.code = DuplicateCase err.errorf(e, "duplicate case %s in type switch", Ts) err.errorf(other, "previous case") check.report(&err) continue L } } seen[T] = e if x != nil && T != nil { check.typeAssertion(e, x, T, true) } } return } // TODO(gri) Once we are certain that typeHash is correct in all situations, use this version of caseTypes instead. // (Currently it may be possible that different types have identical names and import paths due to ImporterFrom.) // // func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[string]syntax.Expr) (T Type) { // var dummy operand // L: // for _, e := range types { // // The spec allows the value nil instead of a type. // var hash string // if check.isNil(e) { // check.expr(nil, &dummy, e) // run e through expr so we get the usual Info recordings // T = nil // hash = "<nil>" // avoid collision with a type named nil // } else { // T = check.varType(e) // if !isValid(T) { // continue L // } // hash = typeHash(T, nil) // } // // look for duplicate types // if other := seen[hash]; other != nil { // // talk about "case" rather than "type" because of nil case // Ts := "nil" // if T != nil { // Ts = TypeString(T, check.qualifier) // } // var err error_ // err.code = _DuplicateCase // err.errorf(e, "duplicate case %s in type switch", Ts) // err.errorf(other, "previous case") // check.report(&err) // continue L // } // seen[hash] = e // if T != nil { // check.typeAssertion(e, x, xtyp, T, true) // } // } // return // } // stmt typechecks statement s. func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) { // statements must end with the same top scope as they started with if debug { defer func(scope *Scope) { // don't check if code is panicking if p := recover(); p != nil { panic(p) } assert(scope == check.scope) }(check.scope) } // process collected function literals before scope changes defer check.processDelayed(len(check.delayed)) // reset context for statements of inner blocks inner := ctxt &^ (fallthroughOk | finalSwitchCase | inTypeSwitch) switch s := s.(type) { case *syntax.EmptyStmt: // ignore case *syntax.DeclStmt: check.declStmt(s.DeclList) case *syntax.LabeledStmt: check.hasLabel = true check.stmt(ctxt, s.Stmt) case *syntax.ExprStmt: // spec: "With the exception of specific built-in functions, // function and method calls and receive operations can appear // in statement context. Such statements may be parenthesized." var x operand kind := check.rawExpr(nil, &x, s.X, nil, false) var msg string var code Code switch x.mode { default: if kind == statement { return } msg = "is not used" code = UnusedExpr case builtin: msg = "must be called" code = UncalledBuiltin case typexpr: msg = "is not an expression" code = NotAnExpr } check.errorf(&x, code, "%s %s", &x, msg) case *syntax.SendStmt: var ch, val operand check.expr(nil, &ch, s.Chan) check.expr(nil, &val, s.Value) if ch.mode == invalid || val.mode == invalid { return } u := coreType(ch.typ) if u == nil { check.errorf(s, InvalidSend, invalidOp+"cannot send to %s: no core type", &ch) return } uch, _ := u.(*Chan) if uch == nil { check.errorf(s, InvalidSend, invalidOp+"cannot send to non-channel %s", &ch) return } if uch.dir == RecvOnly { check.errorf(s, InvalidSend, invalidOp+"cannot send to receive-only channel %s", &ch) return } check.assignment(&val, uch.elem, "send") case *syntax.AssignStmt: if s.Rhs == nil { // x++ or x-- // (no need to call unpackExpr as s.Lhs must be single-valued) var x operand check.expr(nil, &x, s.Lhs) if x.mode == invalid { return } if !allNumeric(x.typ) { check.errorf(s.Lhs, NonNumericIncDec, invalidOp+"%s%s%s (non-numeric type %s)", s.Lhs, s.Op, s.Op, x.typ) return } check.assignVar(s.Lhs, nil, &x, "assignment") return } lhs := syntax.UnpackListExpr(s.Lhs) rhs := syntax.UnpackListExpr(s.Rhs) switch s.Op { case 0: check.assignVars(lhs, rhs) return case syntax.Def: check.shortVarDecl(s.Pos(), lhs, rhs) return } // assignment operations if len(lhs) != 1 || len(rhs) != 1 { check.errorf(s, MultiValAssignOp, "assignment operation %s requires single-valued expressions", s.Op) return } var x operand check.binary(&x, nil, lhs[0], rhs[0], s.Op) check.assignVar(lhs[0], nil, &x, "assignment") case *syntax.CallStmt: kind := "go" if s.Tok == syntax.Defer { kind = "defer" } check.suspendedCall(kind, s.Call) case *syntax.ReturnStmt: res := check.sig.results // Return with implicit results allowed for function with named results. // (If one is named, all are named.) results := syntax.UnpackListExpr(s.Results) if len(results) == 0 && res.Len() > 0 && res.vars[0].name != "" { // spec: "Implementation restriction: A compiler may disallow an empty expression // list in a "return" statement if a different entity (constant, type, or variable) // with the same name as a result parameter is in scope at the place of the return." for _, obj := range res.vars { if alt := check.lookup(obj.name); alt != nil && alt != obj { var err error_ err.code = OutOfScopeResult err.errorf(s, "result parameter %s not in scope at return", obj.name) err.errorf(alt, "inner declaration of %s", obj) check.report(&err) // ok to continue } } } else { var lhs []*Var if res.Len() > 0 { lhs = res.vars } check.initVars(lhs, results, s) } case *syntax.BranchStmt: if s.Label != nil { check.hasLabel = true break // checked in 2nd pass (check.labels) } if check.conf.IgnoreBranchErrors { break } switch s.Tok { case syntax.Break: if ctxt&breakOk == 0 { check.error(s, MisplacedBreak, "break not in for, switch, or select statement") } case syntax.Continue: if ctxt&continueOk == 0 { check.error(s, MisplacedContinue, "continue not in for statement") } case syntax.Fallthrough: if ctxt&fallthroughOk == 0 { var msg string switch { case ctxt&finalSwitchCase != 0: msg = "cannot fallthrough final case in switch" case ctxt&inTypeSwitch != 0: msg = "cannot fallthrough in type switch" default: msg = "fallthrough statement out of place" } check.error(s, MisplacedFallthrough, msg) } case syntax.Goto: // goto's must have labels, should have been caught above fallthrough default: check.errorf(s, InvalidSyntaxTree, "branch statement: %s", s.Tok) } case *syntax.BlockStmt: check.openScope(s, "block") defer check.closeScope() check.stmtList(inner, s.List) case *syntax.IfStmt: check.openScope(s, "if") defer check.closeScope() check.simpleStmt(s.Init) var x operand check.expr(nil, &x, s.Cond) if x.mode != invalid && !allBoolean(x.typ) { check.error(s.Cond, InvalidCond, "non-boolean condition in if statement") } check.stmt(inner, s.Then) // The parser produces a correct AST but if it was modified // elsewhere the else branch may be invalid. Check again. switch s.Else.(type) { case nil: // valid or error already reported case *syntax.IfStmt, *syntax.BlockStmt: check.stmt(inner, s.Else) default: check.error(s.Else, InvalidSyntaxTree, "invalid else branch in if statement") } case *syntax.SwitchStmt: inner |= breakOk check.openScope(s, "switch") defer check.closeScope() check.simpleStmt(s.Init) if g, _ := s.Tag.(*syntax.TypeSwitchGuard); g != nil { check.typeSwitchStmt(inner|inTypeSwitch, s, g) } else { check.switchStmt(inner, s) } case *syntax.SelectStmt: inner |= breakOk check.multipleSelectDefaults(s.Body) for i, clause := range s.Body { if clause == nil { continue // error reported before } // clause.Comm must be a SendStmt, RecvStmt, or default case valid := false var rhs syntax.Expr // rhs of RecvStmt, or nil switch s := clause.Comm.(type) { case nil, *syntax.SendStmt: valid = true case *syntax.AssignStmt: if _, ok := s.Rhs.(*syntax.ListExpr); !ok { rhs = s.Rhs } case *syntax.ExprStmt: rhs = s.X } // if present, rhs must be a receive operation if rhs != nil { if x, _ := syntax.Unparen(rhs).(*syntax.Operation); x != nil && x.Y == nil && x.Op == syntax.Recv { valid = true } } if !valid { check.error(clause.Comm, InvalidSelectCase, "select case must be send or receive (possibly with assignment)") continue } end := s.Rbrace if i+1 < len(s.Body) { end = s.Body[i+1].Pos() } check.openScopeUntil(clause, end, "case") if clause.Comm != nil { check.stmt(inner, clause.Comm) } check.stmtList(inner, clause.Body) check.closeScope() } case *syntax.ForStmt: inner |= breakOk | continueOk if rclause, _ := s.Init.(*syntax.RangeClause); rclause != nil { check.rangeStmt(inner, s, rclause) break } check.openScope(s, "for") defer check.closeScope() check.simpleStmt(s.Init) if s.Cond != nil { var x operand check.expr(nil, &x, s.Cond) if x.mode != invalid && !allBoolean(x.typ) { check.error(s.Cond, InvalidCond, "non-boolean condition in for statement") } } check.simpleStmt(s.Post) // spec: "The init statement may be a short variable // declaration, but the post statement must not." if s, _ := s.Post.(*syntax.AssignStmt); s != nil && s.Op == syntax.Def { // The parser already reported an error. check.use(s.Lhs) // avoid follow-up errors } check.stmt(inner, s.Body) default: check.error(s, InvalidSyntaxTree, "invalid statement") } } func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) { // init statement already handled var x operand if s.Tag != nil { check.expr(nil, &x, s.Tag) // By checking assignment of x to an invisible temporary // (as a compiler would), we get all the relevant checks. check.assignment(&x, nil, "switch expression") if x.mode != invalid && !Comparable(x.typ) && !hasNil(x.typ) { check.errorf(&x, InvalidExprSwitch, "cannot switch on %s (%s is not comparable)", &x, x.typ) x.mode = invalid } } else { // spec: "A missing switch expression is // equivalent to the boolean value true." x.mode = constant_ x.typ = Typ[Bool] x.val = constant.MakeBool(true) // TODO(gri) should have a better position here pos := s.Rbrace if len(s.Body) > 0 { pos = s.Body[0].Pos() } x.expr = syntax.NewName(pos, "true") } check.multipleSwitchDefaults(s.Body) seen := make(valueMap) // map of seen case values to positions and types for i, clause := range s.Body { if clause == nil { check.error(clause, InvalidSyntaxTree, "incorrect expression switch case") continue } end := s.Rbrace inner := inner if i+1 < len(s.Body) { end = s.Body[i+1].Pos() inner |= fallthroughOk } else { inner |= finalSwitchCase } check.caseValues(&x, syntax.UnpackListExpr(clause.Cases), seen) check.openScopeUntil(clause, end, "case") check.stmtList(inner, clause.Body) check.closeScope() } } func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, guard *syntax.TypeSwitchGuard) { // init statement already handled // A type switch guard must be of the form: // // TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" . // \__lhs__/ \___rhs___/ // check lhs, if any lhs := guard.Lhs if lhs != nil { if lhs.Value == "_" { // _ := x.(type) is an invalid short variable declaration check.softErrorf(lhs, NoNewVar, "no new variable on left side of :=") lhs = nil // avoid declared and not used error below } else { check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause } } // check rhs var x operand check.expr(nil, &x, guard.X) if x.mode == invalid { return } // TODO(gri) we may want to permit type switches on type parameter values at some point var sx *operand // switch expression against which cases are compared against; nil if invalid if isTypeParam(x.typ) { check.errorf(&x, InvalidTypeSwitch, "cannot use type switch on type parameter value %s", &x) } else { if _, ok := under(x.typ).(*Interface); ok { sx = &x } else { check.errorf(&x, InvalidTypeSwitch, "%s is not an interface", &x) } } check.multipleSwitchDefaults(s.Body) var lhsVars []*Var // list of implicitly declared lhs variables seen := make(map[Type]syntax.Expr) // map of seen types to positions for i, clause := range s.Body { if clause == nil { check.error(s, InvalidSyntaxTree, "incorrect type switch case") continue } end := s.Rbrace if i+1 < len(s.Body) { end = s.Body[i+1].Pos() } // Check each type in this type switch case. cases := syntax.UnpackListExpr(clause.Cases) T := check.caseTypes(sx, cases, seen) check.openScopeUntil(clause, end, "case") // If lhs exists, declare a corresponding variable in the case-local scope. if lhs != nil { // spec: "The TypeSwitchGuard may include a short variable declaration. // When that form is used, the variable is declared at the beginning of // the implicit block in each clause. In clauses with a case listing // exactly one type, the variable has that type; otherwise, the variable // has the type of the expression in the TypeSwitchGuard." if len(cases) != 1 || T == nil { T = x.typ } obj := NewVar(lhs.Pos(), check.pkg, lhs.Value, T) // TODO(mdempsky): Just use clause.Colon? Why did I even suggest // "at the end of the TypeSwitchCase" in go.dev/issue/16794 instead? scopePos := clause.Pos() // for default clause (len(List) == 0) if n := len(cases); n > 0 { scopePos = syntax.EndPos(cases[n-1]) } check.declare(check.scope, nil, obj, scopePos) check.recordImplicit(clause, obj) // For the "declared and not used" error, all lhs variables act as // one; i.e., if any one of them is 'used', all of them are 'used'. // Collect them for later analysis. lhsVars = append(lhsVars, obj) } check.stmtList(inner, clause.Body) check.closeScope() } // If lhs exists, we must have at least one lhs variable that was used. // (We can't use check.usage because that only looks at one scope; and // we don't want to use the same variable for all scopes and change the // variable type underfoot.) if lhs != nil { var used bool for _, v := range lhsVars { if v.used { used = true } v.used = true // avoid usage error when checking entire function } if !used { check.softErrorf(lhs, UnusedVar, "%s declared and not used", lhs.Value) } } } func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *syntax.RangeClause) { // Convert syntax form to local variables. type Expr = syntax.Expr type identType = syntax.Name identName := func(n *identType) string { return n.Value } sKey := rclause.Lhs // possibly nil var sValue, sExtra syntax.Expr if p, _ := sKey.(*syntax.ListExpr); p != nil { if len(p.ElemList) < 2 { check.error(s, InvalidSyntaxTree, "invalid lhs in range clause") return } // len(p.ElemList) >= 2 sKey = p.ElemList[0] sValue = p.ElemList[1] if len(p.ElemList) > 2 { // delay error reporting until we know more sExtra = p.ElemList[2] } } isDef := rclause.Def rangeVar := rclause.X noNewVarPos := s // Do not use rclause anymore. rclause = nil // Everything from here on is shared between cmd/compile/internal/types2 and go/types. // check expression to iterate over var x operand check.expr(nil, &x, rangeVar) // determine key/value types var key, val Type if x.mode != invalid { // Ranging over a type parameter is permitted if it has a core type. k, v, cause, isFunc, ok := rangeKeyVal(x.typ, func(v goVersion) bool { return check.allowVersion(check.pkg, x.expr, v) }) switch { case !ok && cause != "": check.softErrorf(&x, InvalidRangeExpr, "cannot range over %s: %s", &x, cause) case !ok: check.softErrorf(&x, InvalidRangeExpr, "cannot range over %s", &x) case k == nil && sKey != nil: check.softErrorf(sKey, InvalidIterVar, "range over %s permits no iteration variables", &x) case v == nil && sValue != nil: check.softErrorf(sValue, InvalidIterVar, "range over %s permits only one iteration variable", &x) case sExtra != nil: check.softErrorf(sExtra, InvalidIterVar, "range clause permits at most two iteration variables") case isFunc && ((k == nil) != (sKey == nil) || (v == nil) != (sValue == nil)): var count string switch { case k == nil: count = "no iteration variables" case v == nil: count = "one iteration variable" default: count = "two iteration variables" } check.softErrorf(&x, InvalidIterVar, "range over %s must have %s", &x, count) } key, val = k, v } // Open the for-statement block scope now, after the range clause. // Iteration variables declared with := need to go in this scope (was go.dev/issue/51437). check.openScope(s, "range") defer check.closeScope() // check assignment to/declaration of iteration variables // (irregular assignment, cannot easily map to existing assignment checks) // lhs expressions and initialization value (rhs) types lhs := [2]Expr{sKey, sValue} // sKey, sValue may be nil rhs := [2]Type{key, val} // key, val may be nil rangeOverInt := isInteger(x.typ) if isDef { // short variable declaration var vars []*Var for i, lhs := range lhs { if lhs == nil { continue } // determine lhs variable var obj *Var if ident, _ := lhs.(*identType); ident != nil { // declare new variable name := identName(ident) obj = NewVar(ident.Pos(), check.pkg, name, nil) check.recordDef(ident, obj) // _ variables don't count as new variables if name != "_" { vars = append(vars, obj) } } else { check.errorf(lhs, InvalidSyntaxTree, "cannot declare %s", lhs) obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable } assert(obj.typ == nil) // initialize lhs iteration variable, if any typ := rhs[i] if typ == nil { obj.typ = Typ[Invalid] obj.used = true // don't complain about unused variable continue } if rangeOverInt { assert(i == 0) // at most one iteration variable (rhs[1] == nil for rangeOverInt) check.initVar(obj, &x, "range clause") } else { var y operand y.mode = value y.expr = lhs // we don't have a better rhs expression to use here y.typ = typ check.initVar(obj, &y, "assignment") // error is on variable, use "assignment" not "range clause" } assert(obj.typ != nil) } // declare variables if len(vars) > 0 { scopePos := s.Body.Pos() for _, obj := range vars { check.declare(check.scope, nil /* recordDef already called */, obj, scopePos) } } else { check.error(noNewVarPos, NoNewVar, "no new variables on left side of :=") } } else if sKey != nil /* lhs[0] != nil */ { // ordinary assignment for i, lhs := range lhs { if lhs == nil { continue } // assign to lhs iteration variable, if any typ := rhs[i] if typ == nil { continue } if rangeOverInt { assert(i == 0) // at most one iteration variable (rhs[1] == nil for rangeOverInt) check.assignVar(lhs, nil, &x, "range clause") // If the assignment succeeded, if x was untyped before, it now // has a type inferred via the assignment. It must be an integer. // (go.dev/issues/67027) if x.mode != invalid && !isInteger(x.typ) { check.softErrorf(lhs, InvalidRangeExpr, "cannot use iteration variable of type %s", x.typ) } } else { var y operand y.mode = value y.expr = lhs // we don't have a better rhs expression to use here y.typ = typ check.assignVar(lhs, nil, &y, "assignment") // error is on variable, use "assignment" not "range clause" } } } else if rangeOverInt { // If we don't have any iteration variables, we still need to // check that a (possibly untyped) integer range expression x // is valid. // We do this by checking the assignment _ = x. This ensures // that an untyped x can be converted to a value of its default // type (rune or int). check.assignment(&x, nil, "range clause") } check.stmt(inner, s.Body) } // RangeKeyVal returns the key and value types for a range over typ. // Exported for use by the compiler (does not exist in go/types). func RangeKeyVal(typ Type) (Type, Type) { key, val, _, _, _ := rangeKeyVal(typ, nil) return key, val } // rangeKeyVal returns the key and value type produced by a range clause // over an expression of type typ. // If allowVersion != nil, it is used to check the required language version. // If the range clause is not permitted, rangeKeyVal returns ok = false. // When ok = false, rangeKeyVal may also return a reason in cause. func rangeKeyVal(typ Type, allowVersion func(goVersion) bool) (key, val Type, cause string, isFunc, ok bool) { bad := func(cause string) (Type, Type, string, bool, bool) { return Typ[Invalid], Typ[Invalid], cause, false, false } toSig := func(t Type) *Signature { sig, _ := coreType(t).(*Signature) return sig } orig := typ switch typ := arrayPtrDeref(coreType(typ)).(type) { case nil: return bad("no core type") case *Basic: if isString(typ) { return Typ[Int], universeRune, "", false, true // use 'rune' name } if isInteger(typ) { if allowVersion != nil && !allowVersion(go1_22) { return bad("requires go1.22 or later") } return orig, nil, "", false, true } case *Array: return Typ[Int], typ.elem, "", false, true case *Slice: return Typ[Int], typ.elem, "", false, true case *Map: return typ.key, typ.elem, "", false, true case *Chan: if typ.dir == SendOnly { return bad("receive from send-only channel") } return typ.elem, nil, "", false, true case *Signature: // TODO(gri) when this becomes enabled permanently, add version check if !buildcfg.Experiment.RangeFunc { break } assert(typ.Recv() == nil) switch { case typ.Params().Len() != 1: return bad("func must be func(yield func(...) bool): wrong argument count") case toSig(typ.Params().At(0).Type()) == nil: return bad("func must be func(yield func(...) bool): argument is not func") case typ.Results().Len() != 0: return bad("func must be func(yield func(...) bool): unexpected results") } cb := toSig(typ.Params().At(0).Type()) assert(cb.Recv() == nil) switch { case cb.Params().Len() > 2: return bad("func must be func(yield func(...) bool): yield func has too many parameters") case cb.Results().Len() != 1 || !isBoolean(cb.Results().At(0).Type()): return bad("func must be func(yield func(...) bool): yield func does not return bool") } if cb.Params().Len() >= 1 { key = cb.Params().At(0).Type() } if cb.Params().Len() >= 2 { val = cb.Params().At(1).Type() } return key, val, "", true, true } return } PK ! �XG� � typestring_test.gonu �[��� // Copyright 2012 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 types2_test import ( "internal/testenv" "testing" . "cmd/compile/internal/types2" ) const filename = "<src>" type testEntry struct { src, str string } // dup returns a testEntry where both src and str are the same. func dup(s string) testEntry { return testEntry{s, s} } // types that don't depend on any other type declarations var independentTestTypes = []testEntry{ // basic types dup("int"), dup("float32"), dup("string"), // arrays dup("[10]int"), // slices dup("[]int"), dup("[][]int"), // structs dup("struct{}"), dup("struct{x int}"), {`struct { x, y int z float32 "foo" }`, `struct{x int; y int; z float32 "foo"}`}, {`struct { string elems []complex128 }`, `struct{string; elems []complex128}`}, // pointers dup("*int"), dup("***struct{}"), dup("*struct{a int; b float32}"), // functions dup("func()"), dup("func(x int)"), {"func(x, y int)", "func(x int, y int)"}, {"func(x, y int, z string)", "func(x int, y int, z string)"}, dup("func(int)"), {"func(int, string, byte)", "func(int, string, byte)"}, dup("func() int"), {"func() (string)", "func() string"}, dup("func() (u int)"), {"func() (u, v int, w string)", "func() (u int, v int, w string)"}, dup("func(int) string"), dup("func(x int) string"), dup("func(x int) (u string)"), {"func(x, y int) (u string)", "func(x int, y int) (u string)"}, dup("func(...int) string"), dup("func(x ...int) string"), dup("func(x ...int) (u string)"), {"func(x int, y ...int) (u string)", "func(x int, y ...int) (u string)"}, // interfaces dup("interface{}"), dup("interface{m()}"), dup(`interface{String() string; m(int) float32}`), dup("interface{int | float32 | complex128}"), dup("interface{int | ~float32 | ~complex128}"), dup("any"), dup("interface{comparable}"), {"comparable", "interface{comparable}"}, {"error", "interface{Error() string}"}, // maps dup("map[string]int"), {"map[struct{x, y int}][]byte", "map[struct{x int; y int}][]byte"}, // channels dup("chan<- chan int"), dup("chan<- <-chan int"), dup("<-chan <-chan int"), dup("chan (<-chan int)"), dup("chan<- func()"), dup("<-chan []func() int"), } // types that depend on other type declarations (src in TestTypes) var dependentTestTypes = []testEntry{ // interfaces dup(`interface{io.Reader; io.Writer}`), dup(`interface{m() int; io.Writer}`), {`interface{m() interface{T}}`, `interface{m() interface{generic_p.T}}`}, } func TestTypeString(t *testing.T) { // The Go command is needed for the importer to determine the locations of stdlib .a files. testenv.MustHaveGoBuild(t) var tests []testEntry tests = append(tests, independentTestTypes...) tests = append(tests, dependentTestTypes...) for _, test := range tests { src := `package generic_p; import "io"; type _ io.Writer; type T ` + test.src pkg, err := typecheck(src, nil, nil) if err != nil { t.Errorf("%s: %s", src, err) continue } obj := pkg.Scope().Lookup("T") if obj == nil { t.Errorf("%s: T not found", test.src) continue } typ := obj.Type().Underlying() if got := typ.String(); got != test.str { t.Errorf("%s: got %s, want %s", test.src, got, test.str) } } } func TestQualifiedTypeString(t *testing.T) { p := mustTypecheck("package p; type T int", nil, nil) q := mustTypecheck("package q", nil, nil) pT := p.Scope().Lookup("T").Type() for _, test := range []struct { typ Type this *Package want string }{ {nil, nil, "<nil>"}, {pT, nil, "p.T"}, {pT, p, "T"}, {pT, q, "p.T"}, {NewPointer(pT), p, "*T"}, {NewPointer(pT), q, "*p.T"}, } { qualifier := func(pkg *Package) string { if pkg != test.this { return pkg.Name() } return "" } if got := TypeString(test.typ, qualifier); got != test.want { t.Errorf("TypeString(%s, %s) = %s, want %s", test.this, test.typ, got, test.want) } } } PK ! ](@�F F instantiate_test.gonu �[��� // Copyright 2021 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 types2_test import ( . "cmd/compile/internal/types2" "strings" "testing" ) func TestInstantiateEquality(t *testing.T) { emptySignature := NewSignatureType(nil, nil, nil, nil, nil, false) tests := []struct { src string name1 string targs1 []Type name2 string targs2 []Type wantEqual bool }{ { "package basictype; type T[P any] int", "T", []Type{Typ[Int]}, "T", []Type{Typ[Int]}, true, }, { "package differenttypeargs; type T[P any] int", "T", []Type{Typ[Int]}, "T", []Type{Typ[String]}, false, }, { "package typeslice; type T[P any] int", "T", []Type{NewSlice(Typ[Int])}, "T", []Type{NewSlice(Typ[Int])}, true, }, { // interface{interface{...}} is equivalent to interface{...} "package equivalentinterfaces; type T[P any] int", "T", []Type{ NewInterfaceType([]*Func{NewFunc(nopos, nil, "M", emptySignature)}, nil), }, "T", []Type{ NewInterfaceType( nil, []Type{ NewInterfaceType([]*Func{NewFunc(nopos, nil, "M", emptySignature)}, nil), }, ), }, true, }, { // int|string is equivalent to string|int "package equivalenttypesets; type T[P any] int", "T", []Type{ NewInterfaceType(nil, []Type{ NewUnion([]*Term{NewTerm(false, Typ[Int]), NewTerm(false, Typ[String])}), }), }, "T", []Type{ NewInterfaceType(nil, []Type{ NewUnion([]*Term{NewTerm(false, Typ[String]), NewTerm(false, Typ[Int])}), }), }, true, }, { "package basicfunc; func F[P any]() {}", "F", []Type{Typ[Int]}, "F", []Type{Typ[Int]}, true, }, { "package funcslice; func F[P any]() {}", "F", []Type{NewSlice(Typ[Int])}, "F", []Type{NewSlice(Typ[Int])}, true, }, { "package funcwithparams; func F[P any](x string) float64 { return 0 }", "F", []Type{Typ[Int]}, "F", []Type{Typ[Int]}, true, }, { "package differentfuncargs; func F[P any](x string) float64 { return 0 }", "F", []Type{Typ[Int]}, "F", []Type{Typ[String]}, false, }, { "package funcequality; func F1[P any](x int) {}; func F2[Q any](x int) {}", "F1", []Type{Typ[Int]}, "F2", []Type{Typ[Int]}, false, }, { "package funcsymmetry; func F1[P any](x P) {}; func F2[Q any](x Q) {}", "F1", []Type{Typ[Int]}, "F2", []Type{Typ[Int]}, false, }, } for _, test := range tests { pkg := mustTypecheck(test.src, nil, nil) t.Run(pkg.Name(), func(t *testing.T) { ctxt := NewContext() T1 := pkg.Scope().Lookup(test.name1).Type() res1, err := Instantiate(ctxt, T1, test.targs1, false) if err != nil { t.Fatal(err) } T2 := pkg.Scope().Lookup(test.name2).Type() res2, err := Instantiate(ctxt, T2, test.targs2, false) if err != nil { t.Fatal(err) } if gotEqual := res1 == res2; gotEqual != test.wantEqual { t.Errorf("%s == %s: %t, want %t", res1, res2, gotEqual, test.wantEqual) } }) } } func TestInstantiateNonEquality(t *testing.T) { const src = "package p; type T[P any] int" pkg1 := mustTypecheck(src, nil, nil) pkg2 := mustTypecheck(src, nil, nil) // We consider T1 and T2 to be distinct types, so their instances should not // be deduplicated by the context. T1 := pkg1.Scope().Lookup("T").Type().(*Named) T2 := pkg2.Scope().Lookup("T").Type().(*Named) ctxt := NewContext() res1, err := Instantiate(ctxt, T1, []Type{Typ[Int]}, false) if err != nil { t.Fatal(err) } res2, err := Instantiate(ctxt, T2, []Type{Typ[Int]}, false) if err != nil { t.Fatal(err) } if res1 == res2 { t.Errorf("instance from pkg1 (%s) is pointer-equivalent to instance from pkg2 (%s)", res1, res2) } if Identical(res1, res2) { t.Errorf("instance from pkg1 (%s) is identical to instance from pkg2 (%s)", res1, res2) } } func TestMethodInstantiation(t *testing.T) { const prefix = `package p type T[P any] struct{} var X T[int] ` tests := []struct { decl string want string }{ {"func (r T[P]) m() P", "func (T[int]).m() int"}, {"func (r T[P]) m(P)", "func (T[int]).m(int)"}, {"func (r *T[P]) m(P)", "func (*T[int]).m(int)"}, {"func (r T[P]) m() T[P]", "func (T[int]).m() T[int]"}, {"func (r T[P]) m(T[P])", "func (T[int]).m(T[int])"}, {"func (r T[P]) m(T[P], P, string)", "func (T[int]).m(T[int], int, string)"}, {"func (r T[P]) m(T[P], T[string], T[int])", "func (T[int]).m(T[int], T[string], T[int])"}, } for _, test := range tests { src := prefix + test.decl pkg := mustTypecheck(src, nil, nil) typ := NewPointer(pkg.Scope().Lookup("X").Type()) obj, _, _ := LookupFieldOrMethod(typ, false, pkg, "m") m, _ := obj.(*Func) if m == nil { t.Fatalf(`LookupFieldOrMethod(%s, "m") = %v, want func m`, typ, obj) } if got := ObjectString(m, RelativeTo(pkg)); got != test.want { t.Errorf("instantiated %q, want %q", got, test.want) } } } func TestImmutableSignatures(t *testing.T) { const src = `package p type T[P any] struct{} func (T[P]) m() {} var _ T[int] ` pkg := mustTypecheck(src, nil, nil) typ := pkg.Scope().Lookup("T").Type().(*Named) obj, _, _ := LookupFieldOrMethod(typ, false, pkg, "m") if obj == nil { t.Fatalf(`LookupFieldOrMethod(%s, "m") = %v, want func m`, typ, obj) } // Verify that the original method is not mutated by instantiating T (this // bug manifested when subst did not return a new signature). want := "func (T[P]).m()" if got := stripAnnotations(ObjectString(obj, RelativeTo(pkg))); got != want { t.Errorf("instantiated %q, want %q", got, want) } } // Copied from errors.go. func stripAnnotations(s string) string { var buf strings.Builder for _, r := range s { // strip #'s and subscript digits if r < '₀' || '₀'+10 <= r { // '₀' == U+2080 buf.WriteRune(r) } } if buf.Len() < len(s) { return buf.String() } return s } PK ! }q�xP P main_test.gonu �[��� // Copyright 2022 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 types2_test import ( "go/build" "internal/testenv" "os" "testing" ) func TestMain(m *testing.M) { build.Default.GOROOT = testenv.GOROOT(nil) os.Exit(m.Run()) } PK ! �=J const.gonu �[��� // Copyright 2023 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. // This file implements functions for untyped constant operands. package types2 import ( "cmd/compile/internal/syntax" "go/constant" "go/token" . "internal/types/errors" "math" ) // overflow checks that the constant x is representable by its type. // For untyped constants, it checks that the value doesn't become // arbitrarily large. func (check *Checker) overflow(x *operand, opPos syntax.Pos) { assert(x.mode == constant_) if x.val.Kind() == constant.Unknown { // TODO(gri) We should report exactly what went wrong. At the // moment we don't have the (go/constant) API for that. // See also TODO in go/constant/value.go. check.error(atPos(opPos), InvalidConstVal, "constant result is not representable") return } // Typed constants must be representable in // their type after each constant operation. // x.typ cannot be a type parameter (type // parameters cannot be constant types). if isTyped(x.typ) { check.representable(x, under(x.typ).(*Basic)) return } // Untyped integer values must not grow arbitrarily. const prec = 512 // 512 is the constant precision if x.val.Kind() == constant.Int && constant.BitLen(x.val) > prec { op := opName(x.expr) if op != "" { op += " " } check.errorf(atPos(opPos), InvalidConstVal, "constant %soverflow", op) x.val = constant.MakeUnknown() } } // representableConst reports whether x can be represented as // value of the given basic type and for the configuration // provided (only needed for int/uint sizes). // // If rounded != nil, *rounded is set to the rounded value of x for // representable floating-point and complex values, and to an Int // value for integer values; it is left alone otherwise. // It is ok to provide the addressof the first argument for rounded. // // The check parameter may be nil if representableConst is invoked // (indirectly) through an exported API call (AssignableTo, ConvertibleTo) // because we don't need the Checker's config for those calls. func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *constant.Value) bool { if x.Kind() == constant.Unknown { return true // avoid follow-up errors } var conf *Config if check != nil { conf = check.conf } sizeof := func(T Type) int64 { s := conf.sizeof(T) return s } switch { case isInteger(typ): x := constant.ToInt(x) if x.Kind() != constant.Int { return false } if rounded != nil { *rounded = x } if x, ok := constant.Int64Val(x); ok { switch typ.kind { case Int: var s = uint(sizeof(typ)) * 8 return int64(-1)<<(s-1) <= x && x <= int64(1)<<(s-1)-1 case Int8: const s = 8 return -1<<(s-1) <= x && x <= 1<<(s-1)-1 case Int16: const s = 16 return -1<<(s-1) <= x && x <= 1<<(s-1)-1 case Int32: const s = 32 return -1<<(s-1) <= x && x <= 1<<(s-1)-1 case Int64, UntypedInt: return true case Uint, Uintptr: if s := uint(sizeof(typ)) * 8; s < 64 { return 0 <= x && x <= int64(1)<<s-1 } return 0 <= x case Uint8: const s = 8 return 0 <= x && x <= 1<<s-1 case Uint16: const s = 16 return 0 <= x && x <= 1<<s-1 case Uint32: const s = 32 return 0 <= x && x <= 1<<s-1 case Uint64: return 0 <= x default: unreachable() } } // x does not fit into int64 switch n := constant.BitLen(x); typ.kind { case Uint, Uintptr: var s = uint(sizeof(typ)) * 8 return constant.Sign(x) >= 0 && n <= int(s) case Uint64: return constant.Sign(x) >= 0 && n <= 64 case UntypedInt: return true } case isFloat(typ): x := constant.ToFloat(x) if x.Kind() != constant.Float { return false } switch typ.kind { case Float32: if rounded == nil { return fitsFloat32(x) } r := roundFloat32(x) if r != nil { *rounded = r return true } case Float64: if rounded == nil { return fitsFloat64(x) } r := roundFloat64(x) if r != nil { *rounded = r return true } case UntypedFloat: return true default: unreachable() } case isComplex(typ): x := constant.ToComplex(x) if x.Kind() != constant.Complex { return false } switch typ.kind { case Complex64: if rounded == nil { return fitsFloat32(constant.Real(x)) && fitsFloat32(constant.Imag(x)) } re := roundFloat32(constant.Real(x)) im := roundFloat32(constant.Imag(x)) if re != nil && im != nil { *rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im)) return true } case Complex128: if rounded == nil { return fitsFloat64(constant.Real(x)) && fitsFloat64(constant.Imag(x)) } re := roundFloat64(constant.Real(x)) im := roundFloat64(constant.Imag(x)) if re != nil && im != nil { *rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im)) return true } case UntypedComplex: return true default: unreachable() } case isString(typ): return x.Kind() == constant.String case isBoolean(typ): return x.Kind() == constant.Bool } return false } func fitsFloat32(x constant.Value) bool { f32, _ := constant.Float32Val(x) f := float64(f32) return !math.IsInf(f, 0) } func roundFloat32(x constant.Value) constant.Value { f32, _ := constant.Float32Val(x) f := float64(f32) if !math.IsInf(f, 0) { return constant.MakeFloat64(f) } return nil } func fitsFloat64(x constant.Value) bool { f, _ := constant.Float64Val(x) return !math.IsInf(f, 0) } func roundFloat64(x constant.Value) constant.Value { f, _ := constant.Float64Val(x) if !math.IsInf(f, 0) { return constant.MakeFloat64(f) } return nil } // representable checks that a constant operand is representable in the given // basic type. func (check *Checker) representable(x *operand, typ *Basic) { v, code := check.representation(x, typ) if code != 0 { check.invalidConversion(code, x, typ) x.mode = invalid return } assert(v != nil) x.val = v } // representation returns the representation of the constant operand x as the // basic type typ. // // If no such representation is possible, it returns a non-zero error code. func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, Code) { assert(x.mode == constant_) v := x.val if !representableConst(x.val, check, typ, &v) { if isNumeric(x.typ) && isNumeric(typ) { // numeric conversion : error msg // // integer -> integer : overflows // integer -> float : overflows (actually not possible) // float -> integer : truncated // float -> float : overflows // if !isInteger(x.typ) && isInteger(typ) { return nil, TruncatedFloat } else { return nil, NumericOverflow } } return nil, InvalidConstVal } return v, 0 } func (check *Checker) invalidConversion(code Code, x *operand, target Type) { msg := "cannot convert %s to type %s" switch code { case TruncatedFloat: msg = "%s truncated to %s" case NumericOverflow: msg = "%s overflows %s" } check.errorf(x, code, msg, x, target) } // convertUntyped attempts to set the type of an untyped value to the target type. func (check *Checker) convertUntyped(x *operand, target Type) { newType, val, code := check.implicitTypeAndValue(x, target) if code != 0 { t := target if !isTypeParam(target) { t = safeUnderlying(target) } check.invalidConversion(code, x, t) x.mode = invalid return } if val != nil { x.val = val check.updateExprVal(x.expr, val) } if newType != x.typ { x.typ = newType check.updateExprType(x.expr, newType, false) } } PK ! �M���h �h infer.gonu �[��� // Copyright 2018 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. // This file implements type parameter inference. package types2 import ( "cmd/compile/internal/syntax" "fmt" . "internal/types/errors" "strings" ) // If enableReverseTypeInference is set, uninstantiated and // partially instantiated generic functions may be assigned // (incl. returned) to variables of function type and type // inference will attempt to infer the missing type arguments. // Available with go1.21. const enableReverseTypeInference = true // disable for debugging // infer attempts to infer the complete set of type arguments for generic function instantiation/call // based on the given type parameters tparams, type arguments targs, function parameters params, and // function arguments args, if any. There must be at least one type parameter, no more type arguments // than type parameters, and params and args must match in number (incl. zero). // If reverse is set, an error message's contents are reversed for a better error message for some // errors related to reverse type inference (where the function call is synthetic). // If successful, infer returns the complete list of given and inferred type arguments, one for each // type parameter. Otherwise the result is nil and appropriate errors will be reported. func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand, reverse bool) (inferred []Type) { // Don't verify result conditions if there's no error handler installed: // in that case, an error leads to an exit panic and the result value may // be incorrect. But in that case it doesn't matter because callers won't // be able to use it either. if check.conf.Error != nil { defer func() { assert(inferred == nil || len(inferred) == len(tparams) && !containsNil(inferred)) }() } if traceInference { check.dump("== infer : %s%s ➞ %s", tparams, params, targs) // aligned with rename print below defer func() { check.dump("=> %s ➞ %s\n", tparams, inferred) }() } // There must be at least one type parameter, and no more type arguments than type parameters. n := len(tparams) assert(n > 0 && len(targs) <= n) // Parameters and arguments must match in number. assert(params.Len() == len(args)) // If we already have all type arguments, we're done. if len(targs) == n && !containsNil(targs) { return targs } // If we have invalid (ordinary) arguments, an error was reported before. // Avoid additional inference errors and exit early (go.dev/issue/60434). for _, arg := range args { if arg.mode == invalid { return nil } } // Make sure we have a "full" list of type arguments, some of which may // be nil (unknown). Make a copy so as to not clobber the incoming slice. if len(targs) < n { targs2 := make([]Type, n) copy(targs2, targs) targs = targs2 } // len(targs) == n // Continue with the type arguments we have. Avoid matching generic // parameters that already have type arguments against function arguments: // It may fail because matching uses type identity while parameter passing // uses assignment rules. Instantiate the parameter list with the type // arguments we have, and continue with that parameter list. // Substitute type arguments for their respective type parameters in params, // if any. Note that nil targs entries are ignored by check.subst. // We do this for better error messages; it's not needed for correctness. // For instance, given: // // func f[P, Q any](P, Q) {} // // func _(s string) { // f[int](s, s) // ERROR // } // // With substitution, we get the error: // "cannot use s (variable of type string) as int value in argument to f[int]" // // Without substitution we get the (worse) error: // "type string of s does not match inferred type int for P" // even though the type int was provided (not inferred) for P. // // TODO(gri) We might be able to finesse this in the error message reporting // (which only happens in case of an error) and then avoid doing // the substitution (which always happens). if params.Len() > 0 { smap := makeSubstMap(tparams, targs) params = check.subst(nopos, params, smap, nil, check.context()).(*Tuple) } // Unify parameter and argument types for generic parameters with typed arguments // and collect the indices of generic parameters with untyped arguments. // Terminology: generic parameter = function parameter with a type-parameterized type u := newUnifier(tparams, targs, check.allowVersion(check.pkg, pos, go1_21)) errorf := func(tpar, targ Type, arg *operand) { // provide a better error message if we can targs := u.inferred(tparams) if targs[0] == nil { // The first type parameter couldn't be inferred. // If none of them could be inferred, don't try // to provide the inferred type in the error msg. allFailed := true for _, targ := range targs { if targ != nil { allFailed = false break } } if allFailed { check.errorf(arg, CannotInferTypeArgs, "type %s of %s does not match %s (cannot infer %s)", targ, arg.expr, tpar, typeParamsString(tparams)) return } } smap := makeSubstMap(tparams, targs) // TODO(gri): pass a poser here, rather than arg.Pos(). inferred := check.subst(arg.Pos(), tpar, smap, nil, check.context()) // CannotInferTypeArgs indicates a failure of inference, though the actual // error may be better attributed to a user-provided type argument (hence // InvalidTypeArg). We can't differentiate these cases, so fall back on // the more general CannotInferTypeArgs. if inferred != tpar { if reverse { check.errorf(arg, CannotInferTypeArgs, "inferred type %s for %s does not match type %s of %s", inferred, tpar, targ, arg.expr) } else { check.errorf(arg, CannotInferTypeArgs, "type %s of %s does not match inferred type %s for %s", targ, arg.expr, inferred, tpar) } } else { check.errorf(arg, CannotInferTypeArgs, "type %s of %s does not match %s", targ, arg.expr, tpar) } } // indices of generic parameters with untyped arguments, for later use var untyped []int // --- 1 --- // use information from function arguments if traceInference { u.tracef("== function parameters: %s", params) u.tracef("-- function arguments : %s", args) } for i, arg := range args { if arg.mode == invalid { // An error was reported earlier. Ignore this arg // and continue, we may still be able to infer all // targs resulting in fewer follow-on errors. // TODO(gri) determine if we still need this check continue } par := params.At(i) if isParameterized(tparams, par.typ) || isParameterized(tparams, arg.typ) { // Function parameters are always typed. Arguments may be untyped. // Collect the indices of untyped arguments and handle them later. if isTyped(arg.typ) { if !u.unify(par.typ, arg.typ, assign) { errorf(par.typ, arg.typ, arg) return nil } } else if _, ok := par.typ.(*TypeParam); ok && !arg.isNil() { // Since default types are all basic (i.e., non-composite) types, an // untyped argument will never match a composite parameter type; the // only parameter type it can possibly match against is a *TypeParam. // Thus, for untyped arguments we only need to look at parameter types // that are single type parameters. // Also, untyped nils don't have a default type and can be ignored. untyped = append(untyped, i) } } } if traceInference { inferred := u.inferred(tparams) u.tracef("=> %s ➞ %s\n", tparams, inferred) } // --- 2 --- // use information from type parameter constraints if traceInference { u.tracef("== type parameters: %s", tparams) } // Unify type parameters with their constraints as long // as progress is being made. // // This is an O(n^2) algorithm where n is the number of // type parameters: if there is progress, at least one // type argument is inferred per iteration, and we have // a doubly nested loop. // // In practice this is not a problem because the number // of type parameters tends to be very small (< 5 or so). // (It should be possible for unification to efficiently // signal newly inferred type arguments; then the loops // here could handle the respective type parameters only, // but that will come at a cost of extra complexity which // may not be worth it.) for i := 0; ; i++ { nn := u.unknowns() if traceInference { if i > 0 { fmt.Println() } u.tracef("-- iteration %d", i) } for _, tpar := range tparams { tx := u.at(tpar) core, single := coreTerm(tpar) if traceInference { u.tracef("-- type parameter %s = %s: core(%s) = %s, single = %v", tpar, tx, tpar, core, single) } // If there is a core term (i.e., a core type with tilde information) // unify the type parameter with the core type. if core != nil { // A type parameter can be unified with its core type in two cases. switch { case tx != nil: // The corresponding type argument tx is known. There are 2 cases: // 1) If the core type has a tilde, per spec requirement for tilde // elements, the core type is an underlying (literal) type. // And because of the tilde, the underlying type of tx must match // against the core type. // But because unify automatically matches a defined type against // an underlying literal type, we can simply unify tx with the // core type. // 2) If the core type doesn't have a tilde, we also must unify tx // with the core type. if !u.unify(tx, core.typ, 0) { // TODO(gri) Type parameters that appear in the constraint and // for which we have type arguments inferred should // use those type arguments for a better error message. check.errorf(pos, CannotInferTypeArgs, "%s (type %s) does not satisfy %s", tpar, tx, tpar.Constraint()) return nil } case single && !core.tilde: // The corresponding type argument tx is unknown and there's a single // specific type and no tilde. // In this case the type argument must be that single type; set it. u.set(tpar, core.typ) } } else { if tx != nil { // We don't have a core type, but the type argument tx is known. // It must have (at least) all the methods of the type constraint, // and the method signatures must unify; otherwise tx cannot satisfy // the constraint. // TODO(gri) Now that unification handles interfaces, this code can // be reduced to calling u.unify(tx, tpar.iface(), assign) // (which will compare signatures exactly as we do below). // We leave it as is for now because missingMethod provides // a failure cause which allows for a better error message. // Eventually, unify should return an error with cause. var cause string constraint := tpar.iface() if m, _ := check.missingMethod(tx, constraint, true, func(x, y Type) bool { return u.unify(x, y, exact) }, &cause); m != nil { // TODO(gri) better error message (see TODO above) check.errorf(pos, CannotInferTypeArgs, "%s (type %s) does not satisfy %s %s", tpar, tx, tpar.Constraint(), cause) return nil } } } } if u.unknowns() == nn { break // no progress } } if traceInference { inferred := u.inferred(tparams) u.tracef("=> %s ➞ %s\n", tparams, inferred) } // --- 3 --- // use information from untyped constants if traceInference { u.tracef("== untyped arguments: %v", untyped) } // Some generic parameters with untyped arguments may have been given a type by now. // Collect all remaining parameters that don't have a type yet and determine the // maximum untyped type for each of those parameters, if possible. var maxUntyped map[*TypeParam]Type // lazily allocated (we may not need it) for _, index := range untyped { tpar := params.At(index).typ.(*TypeParam) // is type parameter by construction of untyped if u.at(tpar) == nil { arg := args[index] // arg corresponding to tpar if maxUntyped == nil { maxUntyped = make(map[*TypeParam]Type) } max := maxUntyped[tpar] if max == nil { max = arg.typ } else { m := maxType(max, arg.typ) if m == nil { check.errorf(arg, CannotInferTypeArgs, "mismatched types %s and %s (cannot infer %s)", max, arg.typ, tpar) return nil } max = m } maxUntyped[tpar] = max } } // maxUntyped contains the maximum untyped type for each type parameter // which doesn't have a type yet. Set the respective default types. for tpar, typ := range maxUntyped { d := Default(typ) assert(isTyped(d)) u.set(tpar, d) } // --- simplify --- // u.inferred(tparams) now contains the incoming type arguments plus any additional type // arguments which were inferred. The inferred non-nil entries may still contain // references to other type parameters found in constraints. // For instance, for [A any, B interface{ []C }, C interface{ *A }], if A == int // was given, unification produced the type list [int, []C, *A]. We eliminate the // remaining type parameters by substituting the type parameters in this type list // until nothing changes anymore. inferred = u.inferred(tparams) if debug { for i, targ := range targs { assert(targ == nil || inferred[i] == targ) } } // The data structure of each (provided or inferred) type represents a graph, where // each node corresponds to a type and each (directed) vertex points to a component // type. The substitution process described above repeatedly replaces type parameter // nodes in these graphs with the graphs of the types the type parameters stand for, // which creates a new (possibly bigger) graph for each type. // The substitution process will not stop if the replacement graph for a type parameter // also contains that type parameter. // For instance, for [A interface{ *A }], without any type argument provided for A, // unification produces the type list [*A]. Substituting A in *A with the value for // A will lead to infinite expansion by producing [**A], [****A], [********A], etc., // because the graph A -> *A has a cycle through A. // Generally, cycles may occur across multiple type parameters and inferred types // (for instance, consider [P interface{ *Q }, Q interface{ func(P) }]). // We eliminate cycles by walking the graphs for all type parameters. If a cycle // through a type parameter is detected, killCycles nils out the respective type // (in the inferred list) which kills the cycle, and marks the corresponding type // parameter as not inferred. // // TODO(gri) If useful, we could report the respective cycle as an error. We don't // do this now because type inference will fail anyway, and furthermore, // constraints with cycles of this kind cannot currently be satisfied by // any user-supplied type. But should that change, reporting an error // would be wrong. killCycles(tparams, inferred) // dirty tracks the indices of all types that may still contain type parameters. // We know that nil type entries and entries corresponding to provided (non-nil) // type arguments are clean, so exclude them from the start. var dirty []int for i, typ := range inferred { if typ != nil && (i >= len(targs) || targs[i] == nil) { dirty = append(dirty, i) } } for len(dirty) > 0 { if traceInference { u.tracef("-- simplify %s ➞ %s", tparams, inferred) } // TODO(gri) Instead of creating a new substMap for each iteration, // provide an update operation for substMaps and only change when // needed. Optimization. smap := makeSubstMap(tparams, inferred) n := 0 for _, index := range dirty { t0 := inferred[index] if t1 := check.subst(nopos, t0, smap, nil, check.context()); t1 != t0 { // t0 was simplified to t1. // If t0 was a generic function, but the simplified signature t1 does // not contain any type parameters anymore, the function is not generic // anymore. Remove it's type parameters. (go.dev/issue/59953) // Note that if t0 was a signature, t1 must be a signature, and t1 // can only be a generic signature if it originated from a generic // function argument. Those signatures are never defined types and // thus there is no need to call under below. // TODO(gri) Consider doing this in Checker.subst. // Then this would fall out automatically here and also // in instantiation (where we also explicitly nil out // type parameters). See the *Signature TODO in subst. if sig, _ := t1.(*Signature); sig != nil && sig.TypeParams().Len() > 0 && !isParameterized(tparams, sig) { sig.tparams = nil } inferred[index] = t1 dirty[n] = index n++ } } dirty = dirty[:n] } // Once nothing changes anymore, we may still have type parameters left; // e.g., a constraint with core type *P may match a type parameter Q but // we don't have any type arguments to fill in for *P or Q (go.dev/issue/45548). // Don't let such inferences escape; instead treat them as unresolved. for i, typ := range inferred { if typ == nil || isParameterized(tparams, typ) { obj := tparams[i].obj check.errorf(pos, CannotInferTypeArgs, "cannot infer %s (%s)", obj.name, obj.pos) return nil } } return } // containsNil reports whether list contains a nil entry. func containsNil(list []Type) bool { for _, t := range list { if t == nil { return true } } return false } // renameTParams renames the type parameters in the given type such that each type // parameter is given a new identity. renameTParams returns the new type parameters // and updated type. If the result type is unchanged from the argument type, none // of the type parameters in tparams occurred in the type. // If typ is a generic function, type parameters held with typ are not changed and // must be updated separately if desired. // The positions is only used for debug traces. func (check *Checker) renameTParams(pos syntax.Pos, tparams []*TypeParam, typ Type) ([]*TypeParam, Type) { // For the purpose of type inference we must differentiate type parameters // occurring in explicit type or value function arguments from the type // parameters we are solving for via unification because they may be the // same in self-recursive calls: // // func f[P constraint](x P) { // f(x) // } // // In this example, without type parameter renaming, the P used in the // instantiation f[P] has the same pointer identity as the P we are trying // to solve for through type inference. This causes problems for type // unification. Because any such self-recursive call is equivalent to // a mutually recursive call, type parameter renaming can be used to // create separate, disentangled type parameters. The above example // can be rewritten into the following equivalent code: // // func f[P constraint](x P) { // f2(x) // } // // func f2[P2 constraint](x P2) { // f(x) // } // // Type parameter renaming turns the first example into the second // example by renaming the type parameter P into P2. if len(tparams) == 0 { return nil, typ // nothing to do } tparams2 := make([]*TypeParam, len(tparams)) for i, tparam := range tparams { tname := NewTypeName(tparam.Obj().Pos(), tparam.Obj().Pkg(), tparam.Obj().Name(), nil) tparams2[i] = NewTypeParam(tname, nil) tparams2[i].index = tparam.index // == i } renameMap := makeRenameMap(tparams, tparams2) for i, tparam := range tparams { tparams2[i].bound = check.subst(pos, tparam.bound, renameMap, nil, check.context()) } return tparams2, check.subst(pos, typ, renameMap, nil, check.context()) } // typeParamsString produces a string containing all the type parameter names // in list suitable for human consumption. func typeParamsString(list []*TypeParam) string { // common cases n := len(list) switch n { case 0: return "" case 1: return list[0].obj.name case 2: return list[0].obj.name + " and " + list[1].obj.name } // general case (n > 2) var buf strings.Builder for i, tname := range list[:n-1] { if i > 0 { buf.WriteString(", ") } buf.WriteString(tname.obj.name) } buf.WriteString(", and ") buf.WriteString(list[n-1].obj.name) return buf.String() } // isParameterized reports whether typ contains any of the type parameters of tparams. // If typ is a generic function, isParameterized ignores the type parameter declarations; // it only considers the signature proper (incoming and result parameters). func isParameterized(tparams []*TypeParam, typ Type) bool { w := tpWalker{ tparams: tparams, seen: make(map[Type]bool), } return w.isParameterized(typ) } type tpWalker struct { tparams []*TypeParam seen map[Type]bool } func (w *tpWalker) isParameterized(typ Type) (res bool) { // detect cycles if x, ok := w.seen[typ]; ok { return x } w.seen[typ] = false defer func() { w.seen[typ] = res }() switch t := typ.(type) { case *Basic: // nothing to do case *Alias: return w.isParameterized(Unalias(t)) case *Array: return w.isParameterized(t.elem) case *Slice: return w.isParameterized(t.elem) case *Struct: return w.varList(t.fields) case *Pointer: return w.isParameterized(t.base) case *Tuple: // This case does not occur from within isParameterized // because tuples only appear in signatures where they // are handled explicitly. But isParameterized is also // called by Checker.callExpr with a function result tuple // if instantiation failed (go.dev/issue/59890). return t != nil && w.varList(t.vars) case *Signature: // t.tparams may not be nil if we are looking at a signature // of a generic function type (or an interface method) that is // part of the type we're testing. We don't care about these type // parameters. // Similarly, the receiver of a method may declare (rather than // use) type parameters, we don't care about those either. // Thus, we only need to look at the input and result parameters. return t.params != nil && w.varList(t.params.vars) || t.results != nil && w.varList(t.results.vars) case *Interface: tset := t.typeSet() for _, m := range tset.methods { if w.isParameterized(m.typ) { return true } } return tset.is(func(t *term) bool { return t != nil && w.isParameterized(t.typ) }) case *Map: return w.isParameterized(t.key) || w.isParameterized(t.elem) case *Chan: return w.isParameterized(t.elem) case *Named: for _, t := range t.TypeArgs().list() { if w.isParameterized(t) { return true } } case *TypeParam: return tparamIndex(w.tparams, t) >= 0 default: panic(fmt.Sprintf("unexpected %T", typ)) } return false } func (w *tpWalker) varList(list []*Var) bool { for _, v := range list { if w.isParameterized(v.typ) { return true } } return false } // If the type parameter has a single specific type S, coreTerm returns (S, true). // Otherwise, if tpar has a core type T, it returns a term corresponding to that // core type and false. In that case, if any term of tpar has a tilde, the core // term has a tilde. In all other cases coreTerm returns (nil, false). func coreTerm(tpar *TypeParam) (*term, bool) { n := 0 var single *term // valid if n == 1 var tilde bool tpar.is(func(t *term) bool { if t == nil { assert(n == 0) return false // no terms } n++ single = t if t.tilde { tilde = true } return true }) if n == 1 { if debug { assert(debug && under(single.typ) == coreType(tpar)) } return single, true } if typ := coreType(tpar); typ != nil { // A core type is always an underlying type. // If any term of tpar has a tilde, we don't // have a precise core type and we must return // a tilde as well. return &term{tilde, typ}, false } return nil, false } // killCycles walks through the given type parameters and looks for cycles // created by type parameters whose inferred types refer back to that type // parameter, either directly or indirectly. If such a cycle is detected, // it is killed by setting the corresponding inferred type to nil. // // TODO(gri) Determine if we can simply abort inference as soon as we have // found a single cycle. func killCycles(tparams []*TypeParam, inferred []Type) { w := cycleFinder{tparams, inferred, make(map[Type]bool)} for _, t := range tparams { w.typ(t) // t != nil } } type cycleFinder struct { tparams []*TypeParam inferred []Type seen map[Type]bool } func (w *cycleFinder) typ(typ Type) { if w.seen[typ] { // We have seen typ before. If it is one of the type parameters // in w.tparams, iterative substitution will lead to infinite expansion. // Nil out the corresponding type which effectively kills the cycle. if tpar, _ := typ.(*TypeParam); tpar != nil { if i := tparamIndex(w.tparams, tpar); i >= 0 { // cycle through tpar w.inferred[i] = nil } } // If we don't have one of our type parameters, the cycle is due // to an ordinary recursive type and we can just stop walking it. return } w.seen[typ] = true defer delete(w.seen, typ) switch t := typ.(type) { case *Basic: // nothing to do case *Alias: w.typ(Unalias(t)) case *Array: w.typ(t.elem) case *Slice: w.typ(t.elem) case *Struct: w.varList(t.fields) case *Pointer: w.typ(t.base) // case *Tuple: // This case should not occur because tuples only appear // in signatures where they are handled explicitly. case *Signature: if t.params != nil { w.varList(t.params.vars) } if t.results != nil { w.varList(t.results.vars) } case *Union: for _, t := range t.terms { w.typ(t.typ) } case *Interface: for _, m := range t.methods { w.typ(m.typ) } for _, t := range t.embeddeds { w.typ(t) } case *Map: w.typ(t.key) w.typ(t.elem) case *Chan: w.typ(t.elem) case *Named: for _, tpar := range t.TypeArgs().list() { w.typ(tpar) } case *TypeParam: if i := tparamIndex(w.tparams, t); i >= 0 && w.inferred[i] != nil { w.typ(w.inferred[i]) } default: panic(fmt.Sprintf("unexpected %T", typ)) } } func (w *cycleFinder) varList(list []*Var) { for _, v := range list { w.typ(v.typ) } } // If tpar is a type parameter in list, tparamIndex returns the index // of the type parameter in list. Otherwise the result is < 0. func tparamIndex(list []*TypeParam, tpar *TypeParam) int { for i, p := range list { if p == tpar { return i } } return -1 } PK ! �E˹Z �Z named.gonu �[��� // Copyright 2011 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 types2 import ( "cmd/compile/internal/syntax" "sync" "sync/atomic" ) // Type-checking Named types is subtle, because they may be recursively // defined, and because their full details may be spread across multiple // declarations (via methods). For this reason they are type-checked lazily, // to avoid information being accessed before it is complete. // // Conceptually, it is helpful to think of named types as having two distinct // sets of information: // - "LHS" information, defining their identity: Obj() and TypeArgs() // - "RHS" information, defining their details: TypeParams(), Underlying(), // and methods. // // In this taxonomy, LHS information is available immediately, but RHS // information is lazy. Specifically, a named type N may be constructed in any // of the following ways: // 1. type-checked from the source // 2. loaded eagerly from export data // 3. loaded lazily from export data (when using unified IR) // 4. instantiated from a generic type // // In cases 1, 3, and 4, it is possible that the underlying type or methods of // N may not be immediately available. // - During type-checking, we allocate N before type-checking its underlying // type or methods, so that we may resolve recursive references. // - When loading from export data, we may load its methods and underlying // type lazily using a provided load function. // - After instantiating, we lazily expand the underlying type and methods // (note that instances may be created while still in the process of // type-checking the original type declaration). // // In cases 3 and 4 this lazy construction may also occur concurrently, due to // concurrent use of the type checker API (after type checking or importing has // finished). It is critical that we keep track of state, so that Named types // are constructed exactly once and so that we do not access their details too // soon. // // We achieve this by tracking state with an atomic state variable, and // guarding potentially concurrent calculations with a mutex. At any point in // time this state variable determines which data on N may be accessed. As // state monotonically progresses, any data available at state M may be // accessed without acquiring the mutex at state N, provided N >= M. // // GLOSSARY: Here are a few terms used in this file to describe Named types: // - We say that a Named type is "instantiated" if it has been constructed by // instantiating a generic named type with type arguments. // - We say that a Named type is "declared" if it corresponds to a type // declaration in the source. Instantiated named types correspond to a type // instantiation in the source, not a declaration. But their Origin type is // a declared type. // - We say that a Named type is "resolved" if its RHS information has been // loaded or fully type-checked. For Named types constructed from export // data, this may involve invoking a loader function to extract information // from export data. For instantiated named types this involves reading // information from their origin. // - We say that a Named type is "expanded" if it is an instantiated type and // type parameters in its underlying type and methods have been substituted // with the type arguments from the instantiation. A type may be partially // expanded if some but not all of these details have been substituted. // Similarly, we refer to these individual details (underlying type or // method) as being "expanded". // - When all information is known for a named type, we say it is "complete". // // Some invariants to keep in mind: each declared Named type has a single // corresponding object, and that object's type is the (possibly generic) Named // type. Declared Named types are identical if and only if their pointers are // identical. On the other hand, multiple instantiated Named types may be // identical even though their pointers are not identical. One has to use // Identical to compare them. For instantiated named types, their obj is a // synthetic placeholder that records their position of the corresponding // instantiation in the source (if they were constructed during type checking). // // To prevent infinite expansion of named instances that are created outside of // type-checking, instances share a Context with other instances created during // their expansion. Via the pidgeonhole principle, this guarantees that in the // presence of a cycle of named types, expansion will eventually find an // existing instance in the Context and short-circuit the expansion. // // Once an instance is complete, we can nil out this shared Context to unpin // memory, though this Context may still be held by other incomplete instances // in its "lineage". // A Named represents a named (defined) type. type Named struct { check *Checker // non-nil during type-checking; nil otherwise obj *TypeName // corresponding declared object for declared types; see above for instantiated types // fromRHS holds the type (on RHS of declaration) this *Named type is derived // from (for cycle reporting). Only used by validType, and therefore does not // require synchronization. fromRHS Type // information for instantiated types; nil otherwise inst *instance mu sync.Mutex // guards all fields below state_ uint32 // the current state of this type; must only be accessed atomically underlying Type // possibly a *Named during setup; never a *Named once set up completely tparams *TypeParamList // type parameters, or nil // methods declared for this type (not the method set of this type) // Signatures are type-checked lazily. // For non-instantiated types, this is a fully populated list of methods. For // instantiated types, methods are individually expanded when they are first // accessed. methods []*Func // loader may be provided to lazily load type parameters, underlying type, and methods. loader func(*Named) (tparams []*TypeParam, underlying Type, methods []*Func) } // instance holds information that is only necessary for instantiated named // types. type instance struct { orig *Named // original, uninstantiated type targs *TypeList // type arguments expandedMethods int // number of expanded methods; expandedMethods <= len(orig.methods) ctxt *Context // local Context; set to nil after full expansion } // namedState represents the possible states that a named type may assume. type namedState uint32 const ( unresolved namedState = iota // tparams, underlying type and methods might be unavailable resolved // resolve has run; methods might be incomplete (for instances) complete // all data is known ) // NewNamed returns a new named type for the given type name, underlying type, and associated methods. // If the given type name obj doesn't have a type yet, its type is set to the returned named type. // The underlying type must not be a *Named. func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named { if asNamed(underlying) != nil { panic("underlying type must not be *Named") } return (*Checker)(nil).newNamed(obj, underlying, methods) } // resolve resolves the type parameters, methods, and underlying type of n. // This information may be loaded from a provided loader function, or computed // from an origin type (in the case of instances). // // After resolution, the type parameters, methods, and underlying type of n are // accessible; but if n is an instantiated type, its methods may still be // unexpanded. func (n *Named) resolve() *Named { if n.state() >= resolved { // avoid locking below return n } // TODO(rfindley): if n.check is non-nil we can avoid locking here, since // type-checking is not concurrent. Evaluate if this is worth doing. n.mu.Lock() defer n.mu.Unlock() if n.state() >= resolved { return n } if n.inst != nil { assert(n.underlying == nil) // n is an unresolved instance assert(n.loader == nil) // instances are created by instantiation, in which case n.loader is nil orig := n.inst.orig orig.resolve() underlying := n.expandUnderlying() n.tparams = orig.tparams n.underlying = underlying n.fromRHS = orig.fromRHS // for cycle detection if len(orig.methods) == 0 { n.setState(complete) // nothing further to do n.inst.ctxt = nil } else { n.setState(resolved) } return n } // TODO(mdempsky): Since we're passing n to the loader anyway // (necessary because types2 expects the receiver type for methods // on defined interface types to be the Named rather than the // underlying Interface), maybe it should just handle calling // SetTypeParams, SetUnderlying, and AddMethod instead? Those // methods would need to support reentrant calls though. It would // also make the API more future-proof towards further extensions. if n.loader != nil { assert(n.underlying == nil) assert(n.TypeArgs().Len() == 0) // instances are created by instantiation, in which case n.loader is nil tparams, underlying, methods := n.loader(n) n.tparams = bindTParams(tparams) n.underlying = underlying n.fromRHS = underlying // for cycle detection n.methods = methods n.loader = nil } n.setState(complete) return n } // state atomically accesses the current state of the receiver. func (n *Named) state() namedState { return namedState(atomic.LoadUint32(&n.state_)) } // setState atomically stores the given state for n. // Must only be called while holding n.mu. func (n *Named) setState(state namedState) { atomic.StoreUint32(&n.state_, uint32(state)) } // newNamed is like NewNamed but with a *Checker receiver. func (check *Checker) newNamed(obj *TypeName, underlying Type, methods []*Func) *Named { typ := &Named{check: check, obj: obj, fromRHS: underlying, underlying: underlying, methods: methods} if obj.typ == nil { obj.typ = typ } // Ensure that typ is always sanity-checked. if check != nil { check.needsCleanup(typ) } return typ } // newNamedInstance creates a new named instance for the given origin and type // arguments, recording pos as the position of its synthetic object (for error // reporting). // // If set, expanding is the named type instance currently being expanded, that // led to the creation of this instance. func (check *Checker) newNamedInstance(pos syntax.Pos, orig *Named, targs []Type, expanding *Named) *Named { assert(len(targs) > 0) obj := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil) inst := &instance{orig: orig, targs: newTypeList(targs)} // Only pass the expanding context to the new instance if their packages // match. Since type reference cycles are only possible within a single // package, this is sufficient for the purposes of short-circuiting cycles. // Avoiding passing the context in other cases prevents unnecessary coupling // of types across packages. if expanding != nil && expanding.Obj().pkg == obj.pkg { inst.ctxt = expanding.inst.ctxt } typ := &Named{check: check, obj: obj, inst: inst} obj.typ = typ // Ensure that typ is always sanity-checked. if check != nil { check.needsCleanup(typ) } return typ } func (t *Named) cleanup() { assert(t.inst == nil || t.inst.orig.inst == nil) // Ensure that every defined type created in the course of type-checking has // either non-*Named underlying type, or is unexpanded. // // This guarantees that we don't leak any types whose underlying type is // *Named, because any unexpanded instances will lazily compute their // underlying type by substituting in the underlying type of their origin. // The origin must have either been imported or type-checked and expanded // here, and in either case its underlying type will be fully expanded. switch t.underlying.(type) { case nil: if t.TypeArgs().Len() == 0 { panic("nil underlying") } case *Named: t.under() // t.under may add entries to check.cleaners } t.check = nil } // Obj returns the type name for the declaration defining the named type t. For // instantiated types, this is same as the type name of the origin type. func (t *Named) Obj() *TypeName { if t.inst == nil { return t.obj } return t.inst.orig.obj } // Origin returns the generic type from which the named type t is // instantiated. If t is not an instantiated type, the result is t. func (t *Named) Origin() *Named { if t.inst == nil { return t } return t.inst.orig } // TypeParams returns the type parameters of the named type t, or nil. // The result is non-nil for an (originally) generic type even if it is instantiated. func (t *Named) TypeParams() *TypeParamList { return t.resolve().tparams } // SetTypeParams sets the type parameters of the named type t. // t must not have type arguments. func (t *Named) SetTypeParams(tparams []*TypeParam) { assert(t.inst == nil) t.resolve().tparams = bindTParams(tparams) } // TypeArgs returns the type arguments used to instantiate the named type t. func (t *Named) TypeArgs() *TypeList { if t.inst == nil { return nil } return t.inst.targs } // NumMethods returns the number of explicit methods defined for t. func (t *Named) NumMethods() int { return len(t.Origin().resolve().methods) } // Method returns the i'th method of named type t for 0 <= i < t.NumMethods(). // // For an ordinary or instantiated type t, the receiver base type of this // method is the named type t. For an uninstantiated generic type t, each // method receiver is instantiated with its receiver type parameters. func (t *Named) Method(i int) *Func { t.resolve() if t.state() >= complete { return t.methods[i] } assert(t.inst != nil) // only instances should have incomplete methods orig := t.inst.orig t.mu.Lock() defer t.mu.Unlock() if len(t.methods) != len(orig.methods) { assert(len(t.methods) == 0) t.methods = make([]*Func, len(orig.methods)) } if t.methods[i] == nil { assert(t.inst.ctxt != nil) // we should still have a context remaining from the resolution phase t.methods[i] = t.expandMethod(i) t.inst.expandedMethods++ // Check if we've created all methods at this point. If we have, mark the // type as fully expanded. if t.inst.expandedMethods == len(orig.methods) { t.setState(complete) t.inst.ctxt = nil // no need for a context anymore } } return t.methods[i] } // expandMethod substitutes type arguments in the i'th method for an // instantiated receiver. func (t *Named) expandMethod(i int) *Func { // t.orig.methods is not lazy. origm is the method instantiated with its // receiver type parameters (the "origin" method). origm := t.inst.orig.Method(i) assert(origm != nil) check := t.check // Ensure that the original method is type-checked. if check != nil { check.objDecl(origm, nil) } origSig := origm.typ.(*Signature) rbase, _ := deref(origSig.Recv().Type()) // If rbase is t, then origm is already the instantiated method we're looking // for. In this case, we return origm to preserve the invariant that // traversing Method->Receiver Type->Method should get back to the same // method. // // This occurs if t is instantiated with the receiver type parameters, as in // the use of m in func (r T[_]) m() { r.m() }. if rbase == t { return origm } sig := origSig // We can only substitute if we have a correspondence between type arguments // and type parameters. This check is necessary in the presence of invalid // code. if origSig.RecvTypeParams().Len() == t.inst.targs.Len() { smap := makeSubstMap(origSig.RecvTypeParams().list(), t.inst.targs.list()) var ctxt *Context if check != nil { ctxt = check.context() } sig = check.subst(origm.pos, origSig, smap, t, ctxt).(*Signature) } if sig == origSig { // No substitution occurred, but we still need to create a new signature to // hold the instantiated receiver. copy := *origSig sig = © } var rtyp Type if origm.hasPtrRecv() { rtyp = NewPointer(t) } else { rtyp = t } sig.recv = substVar(origSig.recv, rtyp) return substFunc(origm, sig) } // SetUnderlying sets the underlying type and marks t as complete. // t must not have type arguments. func (t *Named) SetUnderlying(underlying Type) { assert(t.inst == nil) if underlying == nil { panic("underlying type must not be nil") } if asNamed(underlying) != nil { panic("underlying type must not be *Named") } t.resolve().underlying = underlying if t.fromRHS == nil { t.fromRHS = underlying // for cycle detection } } // AddMethod adds method m unless it is already in the method list. // t must not have type arguments. func (t *Named) AddMethod(m *Func) { assert(t.inst == nil) t.resolve() if i, _ := lookupMethod(t.methods, m.pkg, m.name, false); i < 0 { t.methods = append(t.methods, m) } } // TODO(gri) Investigate if Unalias can be moved to where underlying is set. func (t *Named) Underlying() Type { return Unalias(t.resolve().underlying) } func (t *Named) String() string { return TypeString(t, nil) } // ---------------------------------------------------------------------------- // Implementation // // TODO(rfindley): reorganize the loading and expansion methods under this // heading. // under returns the expanded underlying type of n0; possibly by following // forward chains of named types. If an underlying type is found, resolve // the chain by setting the underlying type for each defined type in the // chain before returning it. If no underlying type is found or a cycle // is detected, the result is Typ[Invalid]. If a cycle is detected and // n0.check != nil, the cycle is reported. // // This is necessary because the underlying type of named may be itself a // named type that is incomplete: // // type ( // A B // B *C // C A // ) // // The type of C is the (named) type of A which is incomplete, // and which has as its underlying type the named type B. func (n0 *Named) under() Type { u := n0.Underlying() // If the underlying type of a defined type is not a defined // (incl. instance) type, then that is the desired underlying // type. var n1 *Named switch u1 := u.(type) { case nil: // After expansion via Underlying(), we should never encounter a nil // underlying. panic("nil underlying") default: // common case return u case *Named: // handled below n1 = u1 } if n0.check == nil { panic("Named.check == nil but type is incomplete") } // Invariant: after this point n0 as well as any named types in its // underlying chain should be set up when this function exits. check := n0.check n := n0 seen := make(map[*Named]int) // types that need their underlying type resolved var path []Object // objects encountered, for cycle reporting loop: for { seen[n] = len(seen) path = append(path, n.obj) n = n1 if i, ok := seen[n]; ok { // cycle check.cycleError(path[i:]) u = Typ[Invalid] break } u = n.Underlying() switch u1 := u.(type) { case nil: u = Typ[Invalid] break loop default: break loop case *Named: // Continue collecting *Named types in the chain. n1 = u1 } } for n := range seen { // We should never have to update the underlying type of an imported type; // those underlying types should have been resolved during the import. // Also, doing so would lead to a race condition (was go.dev/issue/31749). // Do this check always, not just in debug mode (it's cheap). if n.obj.pkg != check.pkg { panic("imported type with unresolved underlying type") } n.underlying = u } return u } func (n *Named) lookupMethod(pkg *Package, name string, foldCase bool) (int, *Func) { n.resolve() // If n is an instance, we may not have yet instantiated all of its methods. // Look up the method index in orig, and only instantiate method at the // matching index (if any). i, _ := lookupMethod(n.Origin().methods, pkg, name, foldCase) if i < 0 { return -1, nil } // For instances, m.Method(i) will be different from the orig method. return i, n.Method(i) } // context returns the type-checker context. func (check *Checker) context() *Context { if check.ctxt == nil { check.ctxt = NewContext() } return check.ctxt } // expandUnderlying substitutes type arguments in the underlying type n.orig, // returning the result. Returns Typ[Invalid] if there was an error. func (n *Named) expandUnderlying() Type { check := n.check if check != nil && check.conf.Trace { check.trace(n.obj.pos, "-- Named.expandUnderlying %s", n) check.indent++ defer func() { check.indent-- check.trace(n.obj.pos, "=> %s (tparams = %s, under = %s)", n, n.tparams.list(), n.underlying) }() } assert(n.inst.orig.underlying != nil) if n.inst.ctxt == nil { n.inst.ctxt = NewContext() } orig := n.inst.orig targs := n.inst.targs if asNamed(orig.underlying) != nil { // We should only get a Named underlying type here during type checking // (for example, in recursive type declarations). assert(check != nil) } if orig.tparams.Len() != targs.Len() { // Mismatching arg and tparam length may be checked elsewhere. return Typ[Invalid] } // Ensure that an instance is recorded before substituting, so that we // resolve n for any recursive references. h := n.inst.ctxt.instanceHash(orig, targs.list()) n2 := n.inst.ctxt.update(h, orig, n.TypeArgs().list(), n) assert(n == n2) smap := makeSubstMap(orig.tparams.list(), targs.list()) var ctxt *Context if check != nil { ctxt = check.context() } underlying := n.check.subst(n.obj.pos, orig.underlying, smap, n, ctxt) // If the underlying type of n is an interface, we need to set the receiver of // its methods accurately -- we set the receiver of interface methods on // the RHS of a type declaration to the defined type. if iface, _ := underlying.(*Interface); iface != nil { if methods, copied := replaceRecvType(iface.methods, orig, n); copied { // If the underlying type doesn't actually use type parameters, it's // possible that it wasn't substituted. In this case we need to create // a new *Interface before modifying receivers. if iface == orig.underlying { old := iface iface = check.newInterface() iface.embeddeds = old.embeddeds assert(old.complete) // otherwise we are copying incomplete data iface.complete = old.complete iface.implicit = old.implicit // should be false but be conservative underlying = iface } iface.methods = methods iface.tset = nil // recompute type set with new methods // If check != nil, check.newInterface will have saved the interface for later completion. if check == nil { // golang/go#61561: all newly created interfaces must be fully evaluated iface.typeSet() } } } return underlying } // safeUnderlying returns the underlying type of typ without expanding // instances, to avoid infinite recursion. // // TODO(rfindley): eliminate this function or give it a better name. func safeUnderlying(typ Type) Type { if t := asNamed(typ); t != nil { return t.underlying } return typ.Underlying() } PK ! �FB�U �U check.gonu �[��� // Copyright 2011 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. // This file implements the Check function, which drives type-checking. package types2 import ( "cmd/compile/internal/syntax" "errors" "fmt" "go/constant" "internal/godebug" . "internal/types/errors" ) // nopos indicates an unknown position var nopos syntax.Pos // debugging/development support const debug = false // leave on during development // gotypesalias controls the use of Alias types. var gotypesalias = godebug.New("#gotypesalias") // exprInfo stores information about an untyped expression. type exprInfo struct { isLhs bool // expression is lhs operand of a shift with delayed type-check mode operandMode typ *Basic val constant.Value // constant value; or nil (if not a constant) } // An environment represents the environment within which an object is // type-checked. type environment struct { decl *declInfo // package-level declaration whose init expression/function body is checked scope *Scope // top-most scope for lookups pos syntax.Pos // if valid, identifiers are looked up as if at position pos (used by Eval) iota constant.Value // value of iota in a constant declaration; nil otherwise errpos syntax.Pos // if valid, identifier position of a constant with inherited initializer inTParamList bool // set if inside a type parameter list sig *Signature // function signature if inside a function; nil otherwise isPanic map[*syntax.CallExpr]bool // set of panic call expressions (used for termination check) hasLabel bool // set if a function makes use of labels (only ~1% of functions); unused outside functions hasCallOrRecv bool // set if an expression contains a function call or channel receive operation } // lookup looks up name in the current environment and returns the matching object, or nil. func (env *environment) lookup(name string) Object { _, obj := env.scope.LookupParent(name, env.pos) return obj } // An importKey identifies an imported package by import path and source directory // (directory containing the file containing the import). In practice, the directory // may always be the same, or may not matter. Given an (import path, directory), an // importer must always return the same package (but given two different import paths, // an importer may still return the same package by mapping them to the same package // paths). type importKey struct { path, dir string } // A dotImportKey describes a dot-imported object in the given scope. type dotImportKey struct { scope *Scope name string } // An action describes a (delayed) action. type action struct { f func() // action to be executed desc *actionDesc // action description; may be nil, requires debug to be set } // If debug is set, describef sets a printf-formatted description for action a. // Otherwise, it is a no-op. func (a *action) describef(pos poser, format string, args ...interface{}) { if debug { a.desc = &actionDesc{pos, format, args} } } // An actionDesc provides information on an action. // For debugging only. type actionDesc struct { pos poser format string args []interface{} } // A Checker maintains the state of the type checker. // It must be created with NewChecker. type Checker struct { // package information // (initialized by NewChecker, valid for the life-time of checker) // If enableAlias is set, alias declarations produce an Alias type. // Otherwise the alias information is only in the type name, which // points directly to the actual (aliased) type. enableAlias bool conf *Config ctxt *Context // context for de-duplicating instances pkg *Package *Info version goVersion // accepted language version nextID uint64 // unique Id for type parameters (first valid Id is 1) objMap map[Object]*declInfo // maps package-level objects and (non-interface) methods to declaration info impMap map[importKey]*Package // maps (import path, source directory) to (complete or fake) package valids instanceLookup // valid *Named (incl. instantiated) types per the validType check // pkgPathMap maps package names to the set of distinct import paths we've // seen for that name, anywhere in the import graph. It is used for // disambiguating package names in error messages. // // pkgPathMap is allocated lazily, so that we don't pay the price of building // it on the happy path. seenPkgMap tracks the packages that we've already // walked. pkgPathMap map[string]map[string]bool seenPkgMap map[*Package]bool // information collected during type-checking of a set of package files // (initialized by Files, valid only for the duration of check.Files; // maps and lists are allocated on demand) files []*syntax.File // list of package files versions map[*syntax.PosBase]string // maps file bases to version strings (each file has an entry) imports []*PkgName // list of imported packages dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through recvTParamMap map[*syntax.Name]*TypeParam // maps blank receiver type parameters to their type brokenAliases map[*TypeName]bool // set of aliases with broken (not yet determined) types unionTypeSets map[*Union]*_TypeSet // computed type sets for union types mono monoGraph // graph for detecting non-monomorphizable instantiation loops firstErr error // first error encountered methods map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods untyped map[syntax.Expr]exprInfo // map of expressions without final type delayed []action // stack of delayed action segments; segments are processed in FIFO order objPath []Object // path of object dependencies during type inference (for cycle reporting) cleaners []cleaner // list of types that may need a final cleanup at the end of type-checking // environment within which the current object is type-checked (valid only // for the duration of type-checking a specific object) environment // debugging indent int // indentation for tracing } // addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists func (check *Checker) addDeclDep(to Object) { from := check.decl if from == nil { return // not in a package-level init expression } if _, found := check.objMap[to]; !found { return // to is not a package-level object } from.addDep(to) } // Note: The following three alias-related functions are only used // when Alias types are not enabled. // brokenAlias records that alias doesn't have a determined type yet. // It also sets alias.typ to Typ[Invalid]. // Not used if check.enableAlias is set. func (check *Checker) brokenAlias(alias *TypeName) { assert(!check.enableAlias) if check.brokenAliases == nil { check.brokenAliases = make(map[*TypeName]bool) } check.brokenAliases[alias] = true alias.typ = Typ[Invalid] } // validAlias records that alias has the valid type typ (possibly Typ[Invalid]). func (check *Checker) validAlias(alias *TypeName, typ Type) { assert(!check.enableAlias) delete(check.brokenAliases, alias) alias.typ = typ } // isBrokenAlias reports whether alias doesn't have a determined type yet. func (check *Checker) isBrokenAlias(alias *TypeName) bool { assert(!check.enableAlias) return check.brokenAliases[alias] } func (check *Checker) rememberUntyped(e syntax.Expr, lhs bool, mode operandMode, typ *Basic, val constant.Value) { m := check.untyped if m == nil { m = make(map[syntax.Expr]exprInfo) check.untyped = m } m[e] = exprInfo{lhs, mode, typ, val} } // later pushes f on to the stack of actions that will be processed later; // either at the end of the current statement, or in case of a local constant // or variable declaration, before the constant or variable is in scope // (so that f still sees the scope before any new declarations). // later returns the pushed action so one can provide a description // via action.describef for debugging, if desired. func (check *Checker) later(f func()) *action { i := len(check.delayed) check.delayed = append(check.delayed, action{f: f}) return &check.delayed[i] } // push pushes obj onto the object path and returns its index in the path. func (check *Checker) push(obj Object) int { check.objPath = append(check.objPath, obj) return len(check.objPath) - 1 } // pop pops and returns the topmost object from the object path. func (check *Checker) pop() Object { i := len(check.objPath) - 1 obj := check.objPath[i] check.objPath[i] = nil check.objPath = check.objPath[:i] return obj } type cleaner interface { cleanup() } // needsCleanup records objects/types that implement the cleanup method // which will be called at the end of type-checking. func (check *Checker) needsCleanup(c cleaner) { check.cleaners = append(check.cleaners, c) } // NewChecker returns a new Checker instance for a given package. // Package files may be added incrementally via checker.Files. func NewChecker(conf *Config, pkg *Package, info *Info) *Checker { // make sure we have a configuration if conf == nil { conf = new(Config) } // make sure we have an info struct if info == nil { info = new(Info) } // Note: clients may call NewChecker with the Unsafe package, which is // globally shared and must not be mutated. Therefore NewChecker must not // mutate *pkg. // // (previously, pkg.goVersion was mutated here: go.dev/issue/61212) return &Checker{ enableAlias: gotypesalias.Value() == "1", conf: conf, ctxt: conf.Context, pkg: pkg, Info: info, version: asGoVersion(conf.GoVersion), objMap: make(map[Object]*declInfo), impMap: make(map[importKey]*Package), } } // initFiles initializes the files-specific portion of checker. // The provided files must all belong to the same package. func (check *Checker) initFiles(files []*syntax.File) { // start with a clean slate (check.Files may be called multiple times) check.files = nil check.imports = nil check.dotImportMap = nil check.firstErr = nil check.methods = nil check.untyped = nil check.delayed = nil check.objPath = nil check.cleaners = nil // determine package name and collect valid files pkg := check.pkg for _, file := range files { switch name := file.PkgName.Value; pkg.name { case "": if name != "_" { pkg.name = name } else { check.error(file.PkgName, BlankPkgName, "invalid package name _") } fallthrough case name: check.files = append(check.files, file) default: check.errorf(file, MismatchedPkgName, "package %s; expected %s", name, pkg.name) // ignore this file } } // reuse Info.FileVersions if provided versions := check.Info.FileVersions if versions == nil { versions = make(map[*syntax.PosBase]string) } check.versions = versions pkgVersionOk := check.version.isValid() downgradeOk := check.version.cmp(go1_21) >= 0 // determine Go version for each file for _, file := range check.files { // use unaltered Config.GoVersion by default // (This version string may contain dot-release numbers as in go1.20.1, // unlike file versions which are Go language versions only, if valid.) v := check.conf.GoVersion // use the file version, if applicable // (file versions are either the empty string or of the form go1.dd) if pkgVersionOk { fileVersion := asGoVersion(file.GoVersion) if fileVersion.isValid() { cmp := fileVersion.cmp(check.version) // Go 1.21 introduced the feature of setting the go.mod // go line to an early version of Go and allowing //go:build lines // to “upgrade” (cmp > 0) the Go version in a given file. // We can do that backwards compatibly. // // Go 1.21 also introduced the feature of allowing //go:build lines // to “downgrade” (cmp < 0) the Go version in a given file. // That can't be done compatibly in general, since before the // build lines were ignored and code got the module's Go version. // To work around this, downgrades are only allowed when the // module's Go version is Go 1.21 or later. // // If there is no valid check.version, then we don't really know what // Go version to apply. // Legacy tools may do this, and they historically have accepted everything. // Preserve that behavior by ignoring //go:build constraints entirely in that // case (!pkgVersionOk). if cmp > 0 || cmp < 0 && downgradeOk { v = file.GoVersion } } } versions[base(file.Pos())] = v // base(file.Pos()) may be nil for tests } } // A bailout panic is used for early termination. type bailout struct{} func (check *Checker) handleBailout(err *error) { switch p := recover().(type) { case nil, bailout: // normal return or early exit *err = check.firstErr default: // re-panic panic(p) } } // Files checks the provided files as part of the checker's package. func (check *Checker) Files(files []*syntax.File) error { return check.checkFiles(files) } var errBadCgo = errors.New("cannot use FakeImportC and go115UsesCgo together") func (check *Checker) checkFiles(files []*syntax.File) (err error) { if check.pkg == Unsafe { // Defensive handling for Unsafe, which cannot be type checked, and must // not be mutated. See https://go.dev/issue/61212 for an example of where // Unsafe is passed to NewChecker. return nil } // Note: NewChecker doesn't return an error, so we need to check the version here. if check.version.cmp(go_current) > 0 { return fmt.Errorf("package requires newer Go version %v", check.version) } if check.conf.FakeImportC && check.conf.go115UsesCgo { return errBadCgo } defer check.handleBailout(&err) print := func(msg string) { if check.conf.Trace { fmt.Println() fmt.Println(msg) } } print("== initFiles ==") check.initFiles(files) print("== collectObjects ==") check.collectObjects() print("== packageObjects ==") check.packageObjects() print("== processDelayed ==") check.processDelayed(0) // incl. all functions print("== cleanup ==") check.cleanup() print("== initOrder ==") check.initOrder() if !check.conf.DisableUnusedImportCheck { print("== unusedImports ==") check.unusedImports() } print("== recordUntyped ==") check.recordUntyped() if check.firstErr == nil { // TODO(mdempsky): Ensure monomorph is safe when errors exist. check.monomorph() } check.pkg.goVersion = check.conf.GoVersion check.pkg.complete = true // no longer needed - release memory check.imports = nil check.dotImportMap = nil check.pkgPathMap = nil check.seenPkgMap = nil check.recvTParamMap = nil check.brokenAliases = nil check.unionTypeSets = nil check.ctxt = nil // TODO(gri) There's more memory we should release at this point. return } // processDelayed processes all delayed actions pushed after top. func (check *Checker) processDelayed(top int) { // If each delayed action pushes a new action, the // stack will continue to grow during this loop. // However, it is only processing functions (which // are processed in a delayed fashion) that may // add more actions (such as nested functions), so // this is a sufficiently bounded process. for i := top; i < len(check.delayed); i++ { a := &check.delayed[i] if check.conf.Trace { if a.desc != nil { check.trace(a.desc.pos.Pos(), "-- "+a.desc.format, a.desc.args...) } else { check.trace(nopos, "-- delayed %p", a.f) } } a.f() // may append to check.delayed if check.conf.Trace { fmt.Println() } } assert(top <= len(check.delayed)) // stack must not have shrunk check.delayed = check.delayed[:top] } // cleanup runs cleanup for all collected cleaners. func (check *Checker) cleanup() { // Don't use a range clause since Named.cleanup may add more cleaners. for i := 0; i < len(check.cleaners); i++ { check.cleaners[i].cleanup() } check.cleaners = nil } func (check *Checker) record(x *operand) { // convert x into a user-friendly set of values // TODO(gri) this code can be simplified var typ Type var val constant.Value switch x.mode { case invalid: typ = Typ[Invalid] case novalue: typ = (*Tuple)(nil) case constant_: typ = x.typ val = x.val default: typ = x.typ } assert(x.expr != nil && typ != nil) if isUntyped(typ) { // delay type and value recording until we know the type // or until the end of type checking check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val) } else { check.recordTypeAndValue(x.expr, x.mode, typ, val) } } func (check *Checker) recordUntyped() { if !debug && !check.recordTypes() { return // nothing to do } for x, info := range check.untyped { if debug && isTyped(info.typ) { check.dump("%v: %s (type %s) is typed", atPos(x), x, info.typ) unreachable() } check.recordTypeAndValue(x, info.mode, info.typ, info.val) } } func (check *Checker) recordTypeAndValue(x syntax.Expr, mode operandMode, typ Type, val constant.Value) { assert(x != nil) assert(typ != nil) if mode == invalid { return // omit } if mode == constant_ { assert(val != nil) // We check allBasic(typ, IsConstType) here as constant expressions may be // recorded as type parameters. assert(!isValid(typ) || allBasic(typ, IsConstType)) } if m := check.Types; m != nil { m[x] = TypeAndValue{mode, typ, val} } if check.StoreTypesInSyntax { tv := TypeAndValue{mode, typ, val} stv := syntax.TypeAndValue{Type: typ, Value: val} if tv.IsVoid() { stv.SetIsVoid() } if tv.IsType() { stv.SetIsType() } if tv.IsBuiltin() { stv.SetIsBuiltin() } if tv.IsValue() { stv.SetIsValue() } if tv.IsNil() { stv.SetIsNil() } if tv.Addressable() { stv.SetAddressable() } if tv.Assignable() { stv.SetAssignable() } if tv.HasOk() { stv.SetHasOk() } x.SetTypeInfo(stv) } } func (check *Checker) recordBuiltinType(f syntax.Expr, sig *Signature) { // f must be a (possibly parenthesized, possibly qualified) // identifier denoting a built-in (including unsafe's non-constant // functions Add and Slice): record the signature for f and possible // children. for { check.recordTypeAndValue(f, builtin, sig, nil) switch p := f.(type) { case *syntax.Name, *syntax.SelectorExpr: return // we're done case *syntax.ParenExpr: f = p.X default: unreachable() } } } // recordCommaOkTypes updates recorded types to reflect that x is used in a commaOk context // (and therefore has tuple type). func (check *Checker) recordCommaOkTypes(x syntax.Expr, a []*operand) { assert(x != nil) assert(len(a) == 2) if a[0].mode == invalid { return } t0, t1 := a[0].typ, a[1].typ assert(isTyped(t0) && isTyped(t1) && (isBoolean(t1) || t1 == universeError)) if m := check.Types; m != nil { for { tv := m[x] assert(tv.Type != nil) // should have been recorded already pos := x.Pos() tv.Type = NewTuple( NewVar(pos, check.pkg, "", t0), NewVar(pos, check.pkg, "", t1), ) m[x] = tv // if x is a parenthesized expression (p.X), update p.X p, _ := x.(*syntax.ParenExpr) if p == nil { break } x = p.X } } if check.StoreTypesInSyntax { // Note: this loop is duplicated because the type of tv is different. // Above it is types2.TypeAndValue, here it is syntax.TypeAndValue. for { tv := x.GetTypeInfo() assert(tv.Type != nil) // should have been recorded already pos := x.Pos() tv.Type = NewTuple( NewVar(pos, check.pkg, "", t0), NewVar(pos, check.pkg, "", t1), ) x.SetTypeInfo(tv) p, _ := x.(*syntax.ParenExpr) if p == nil { break } x = p.X } } } // recordInstance records instantiation information into check.Info, if the // Instances map is non-nil. The given expr must be an ident, selector, or // index (list) expr with ident or selector operand. // // TODO(rfindley): the expr parameter is fragile. See if we can access the // instantiated identifier in some other way. func (check *Checker) recordInstance(expr syntax.Expr, targs []Type, typ Type) { ident := instantiatedIdent(expr) assert(ident != nil) assert(typ != nil) if m := check.Instances; m != nil { m[ident] = Instance{newTypeList(targs), typ} } } func instantiatedIdent(expr syntax.Expr) *syntax.Name { var selOrIdent syntax.Expr switch e := expr.(type) { case *syntax.IndexExpr: selOrIdent = e.X case *syntax.SelectorExpr, *syntax.Name: selOrIdent = e } switch x := selOrIdent.(type) { case *syntax.Name: return x case *syntax.SelectorExpr: return x.Sel } panic("instantiated ident not found") } func (check *Checker) recordDef(id *syntax.Name, obj Object) { assert(id != nil) if m := check.Defs; m != nil { m[id] = obj } } func (check *Checker) recordUse(id *syntax.Name, obj Object) { assert(id != nil) assert(obj != nil) if m := check.Uses; m != nil { m[id] = obj } } func (check *Checker) recordImplicit(node syntax.Node, obj Object) { assert(node != nil) assert(obj != nil) if m := check.Implicits; m != nil { m[node] = obj } } func (check *Checker) recordSelection(x *syntax.SelectorExpr, kind SelectionKind, recv Type, obj Object, index []int, indirect bool) { assert(obj != nil && (recv == nil || len(index) > 0)) check.recordUse(x.Sel, obj) if m := check.Selections; m != nil { m[x] = &Selection{kind, recv, obj, index, indirect} } } func (check *Checker) recordScope(node syntax.Node, scope *Scope) { assert(node != nil) assert(scope != nil) if m := check.Scopes; m != nil { m[node] = scope } } PK ! =*��@. @. subst.gonu �[��� // Copyright 2018 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. // This file implements type parameter substitution. package types2 import ( "cmd/compile/internal/syntax" ) type substMap map[*TypeParam]Type // makeSubstMap creates a new substitution map mapping tpars[i] to targs[i]. // If targs[i] is nil, tpars[i] is not substituted. func makeSubstMap(tpars []*TypeParam, targs []Type) substMap { assert(len(tpars) == len(targs)) proj := make(substMap, len(tpars)) for i, tpar := range tpars { proj[tpar] = targs[i] } return proj } // makeRenameMap is like makeSubstMap, but creates a map used to rename type // parameters in from with the type parameters in to. func makeRenameMap(from, to []*TypeParam) substMap { assert(len(from) == len(to)) proj := make(substMap, len(from)) for i, tpar := range from { proj[tpar] = to[i] } return proj } func (m substMap) empty() bool { return len(m) == 0 } func (m substMap) lookup(tpar *TypeParam) Type { if t := m[tpar]; t != nil { return t } return tpar } // subst returns the type typ with its type parameters tpars replaced by the // corresponding type arguments targs, recursively. subst doesn't modify the // incoming type. If a substitution took place, the result type is different // from the incoming type. // // If expanding is non-nil, it is the instance type currently being expanded. // One of expanding or ctxt must be non-nil. func (check *Checker) subst(pos syntax.Pos, typ Type, smap substMap, expanding *Named, ctxt *Context) Type { assert(expanding != nil || ctxt != nil) if smap.empty() { return typ } // common cases switch t := typ.(type) { case *Basic: return typ // nothing to do case *TypeParam: return smap.lookup(t) } // general case subst := subster{ pos: pos, smap: smap, check: check, expanding: expanding, ctxt: ctxt, } return subst.typ(typ) } type subster struct { pos syntax.Pos smap substMap check *Checker // nil if called via Instantiate expanding *Named // if non-nil, the instance that is being expanded ctxt *Context } func (subst *subster) typ(typ Type) Type { switch t := typ.(type) { case nil: // Call typOrNil if it's possible that typ is nil. panic("nil typ") case *Basic: // nothing to do case *Alias: rhs := subst.typ(t.fromRHS) if rhs != t.fromRHS { // This branch cannot be reached because the RHS of an alias // may only contain type parameters of an enclosing function. // Such function bodies are never "instantiated" and thus // substitution is not called on locally declared alias types. // TODO(gri) adjust once parameterized aliases are supported panic("unreachable for unparameterized aliases") // return subst.check.newAlias(t.obj, rhs) } case *Array: elem := subst.typOrNil(t.elem) if elem != t.elem { return &Array{len: t.len, elem: elem} } case *Slice: elem := subst.typOrNil(t.elem) if elem != t.elem { return &Slice{elem: elem} } case *Struct: if fields, copied := subst.varList(t.fields); copied { s := &Struct{fields: fields, tags: t.tags} s.markComplete() return s } case *Pointer: base := subst.typ(t.base) if base != t.base { return &Pointer{base: base} } case *Tuple: return subst.tuple(t) case *Signature: // Preserve the receiver: it is handled during *Interface and *Named type // substitution. // // Naively doing the substitution here can lead to an infinite recursion in // the case where the receiver is an interface. For example, consider the // following declaration: // // type T[A any] struct { f interface{ m() } } // // In this case, the type of f is an interface that is itself the receiver // type of all of its methods. Because we have no type name to break // cycles, substituting in the recv results in an infinite loop of // recv->interface->recv->interface->... recv := t.recv params := subst.tuple(t.params) results := subst.tuple(t.results) if params != t.params || results != t.results { return &Signature{ rparams: t.rparams, // TODO(gri) why can't we nil out tparams here, rather than in instantiate? tparams: t.tparams, // instantiated signatures have a nil scope recv: recv, params: params, results: results, variadic: t.variadic, } } case *Union: terms, copied := subst.termlist(t.terms) if copied { // term list substitution may introduce duplicate terms (unlikely but possible). // This is ok; lazy type set computation will determine the actual type set // in normal form. return &Union{terms} } case *Interface: methods, mcopied := subst.funcList(t.methods) embeddeds, ecopied := subst.typeList(t.embeddeds) if mcopied || ecopied { iface := subst.check.newInterface() iface.embeddeds = embeddeds iface.embedPos = t.embedPos iface.implicit = t.implicit assert(t.complete) // otherwise we are copying incomplete data iface.complete = t.complete // If we've changed the interface type, we may need to replace its // receiver if the receiver type is the original interface. Receivers of // *Named type are replaced during named type expansion. // // Notably, it's possible to reach here and not create a new *Interface, // even though the receiver type may be parameterized. For example: // // type T[P any] interface{ m() } // // In this case the interface will not be substituted here, because its // method signatures do not depend on the type parameter P, but we still // need to create new interface methods to hold the instantiated // receiver. This is handled by Named.expandUnderlying. iface.methods, _ = replaceRecvType(methods, t, iface) // If check != nil, check.newInterface will have saved the interface for later completion. if subst.check == nil { // golang/go#61561: all newly created interfaces must be completed iface.typeSet() } return iface } case *Map: key := subst.typ(t.key) elem := subst.typ(t.elem) if key != t.key || elem != t.elem { return &Map{key: key, elem: elem} } case *Chan: elem := subst.typ(t.elem) if elem != t.elem { return &Chan{dir: t.dir, elem: elem} } case *Named: // dump is for debugging dump := func(string, ...interface{}) {} if subst.check != nil && subst.check.conf.Trace { subst.check.indent++ defer func() { subst.check.indent-- }() dump = func(format string, args ...interface{}) { subst.check.trace(subst.pos, format, args...) } } // subst is called during expansion, so in this function we need to be // careful not to call any methods that would cause t to be expanded: doing // so would result in deadlock. // // So we call t.Origin().TypeParams() rather than t.TypeParams(). orig := t.Origin() n := orig.TypeParams().Len() if n == 0 { dump(">>> %s is not parameterized", t) return t // type is not parameterized } var newTArgs []Type if t.TypeArgs().Len() != n { return Typ[Invalid] // error reported elsewhere } // already instantiated dump(">>> %s already instantiated", t) // For each (existing) type argument targ, determine if it needs // to be substituted; i.e., if it is or contains a type parameter // that has a type argument for it. for i, targ := range t.TypeArgs().list() { dump(">>> %d targ = %s", i, targ) new_targ := subst.typ(targ) if new_targ != targ { dump(">>> substituted %d targ %s => %s", i, targ, new_targ) if newTArgs == nil { newTArgs = make([]Type, n) copy(newTArgs, t.TypeArgs().list()) } newTArgs[i] = new_targ } } if newTArgs == nil { dump(">>> nothing to substitute in %s", t) return t // nothing to substitute } // Create a new instance and populate the context to avoid endless // recursion. The position used here is irrelevant because validation only // occurs on t (we don't call validType on named), but we use subst.pos to // help with debugging. return subst.check.instance(subst.pos, orig, newTArgs, subst.expanding, subst.ctxt) case *TypeParam: return subst.smap.lookup(t) default: unreachable() } return typ } // typOrNil is like typ but if the argument is nil it is replaced with Typ[Invalid]. // A nil type may appear in pathological cases such as type T[P any] []func(_ T([]_)) // where an array/slice element is accessed before it is set up. func (subst *subster) typOrNil(typ Type) Type { if typ == nil { return Typ[Invalid] } return subst.typ(typ) } func (subst *subster) var_(v *Var) *Var { if v != nil { if typ := subst.typ(v.typ); typ != v.typ { return substVar(v, typ) } } return v } func substVar(v *Var, typ Type) *Var { copy := *v copy.typ = typ copy.origin = v.Origin() return © } func (subst *subster) tuple(t *Tuple) *Tuple { if t != nil { if vars, copied := subst.varList(t.vars); copied { return &Tuple{vars: vars} } } return t } func (subst *subster) varList(in []*Var) (out []*Var, copied bool) { out = in for i, v := range in { if w := subst.var_(v); w != v { if !copied { // first variable that got substituted => allocate new out slice // and copy all variables new := make([]*Var, len(in)) copy(new, out) out = new copied = true } out[i] = w } } return } func (subst *subster) func_(f *Func) *Func { if f != nil { if typ := subst.typ(f.typ); typ != f.typ { return substFunc(f, typ) } } return f } func substFunc(f *Func, typ Type) *Func { copy := *f copy.typ = typ copy.origin = f.Origin() return © } func (subst *subster) funcList(in []*Func) (out []*Func, copied bool) { out = in for i, f := range in { if g := subst.func_(f); g != f { if !copied { // first function that got substituted => allocate new out slice // and copy all functions new := make([]*Func, len(in)) copy(new, out) out = new copied = true } out[i] = g } } return } func (subst *subster) typeList(in []Type) (out []Type, copied bool) { out = in for i, t := range in { if u := subst.typ(t); u != t { if !copied { // first function that got substituted => allocate new out slice // and copy all functions new := make([]Type, len(in)) copy(new, out) out = new copied = true } out[i] = u } } return } func (subst *subster) termlist(in []*Term) (out []*Term, copied bool) { out = in for i, t := range in { if u := subst.typ(t.typ); u != t.typ { if !copied { // first function that got substituted => allocate new out slice // and copy all functions new := make([]*Term, len(in)) copy(new, out) out = new copied = true } out[i] = NewTerm(t.tilde, u) } } return } // replaceRecvType updates any function receivers that have type old to have // type new. It does not modify the input slice; if modifications are required, // the input slice and any affected signatures will be copied before mutating. // // The resulting out slice contains the updated functions, and copied reports // if anything was modified. func replaceRecvType(in []*Func, old, new Type) (out []*Func, copied bool) { out = in for i, method := range in { sig := method.Type().(*Signature) if sig.recv != nil && sig.recv.Type() == old { if !copied { // Allocate a new methods slice before mutating for the first time. // This is defensive, as we may share methods across instantiations of // a given interface type if they do not get substituted. out = make([]*Func, len(in)) copy(out, in) copied = true } newsig := *sig newsig.recv = substVar(sig.recv, new) out[i] = substFunc(method, &newsig) } } return } PK ! ^<'�N �N lookup.gonu �[��� // Copyright 2013 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. // This file implements various field and method lookup functions. package types2 import ( "bytes" "cmd/compile/internal/syntax" "strings" ) // Internal use of LookupFieldOrMethod: If the obj result is a method // associated with a concrete (non-interface) type, the method's signature // may not be fully set up. Call Checker.objDecl(obj, nil) before accessing // the method's type. // LookupFieldOrMethod looks up a field or method with given package and name // in T and returns the corresponding *Var or *Func, an index sequence, and a // bool indicating if there were any pointer indirections on the path to the // field or method. If addressable is set, T is the type of an addressable // variable (only matters for method lookups). T must not be nil. // // The last index entry is the field or method index in the (possibly embedded) // type where the entry was found, either: // // 1. the list of declared methods of a named type; or // 2. the list of all methods (method set) of an interface type; or // 3. the list of fields of a struct type. // // The earlier index entries are the indices of the embedded struct fields // traversed to get to the found entry, starting at depth 0. // // If no entry is found, a nil object is returned. In this case, the returned // index and indirect values have the following meaning: // // - If index != nil, the index sequence points to an ambiguous entry // (the same name appeared more than once at the same embedding level). // // - If indirect is set, a method with a pointer receiver type was found // but there was no pointer on the path from the actual receiver type to // the method's formal receiver base type, nor was the receiver addressable. func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) { if T == nil { panic("LookupFieldOrMethod on nil type") } // Methods cannot be associated to a named pointer type. // (spec: "The type denoted by T is called the receiver base type; // it must not be a pointer or interface type and it must be declared // in the same package as the method."). // Thus, if we have a named pointer type, proceed with the underlying // pointer type but discard the result if it is a method since we would // not have found it for T (see also go.dev/issue/8590). if t := asNamed(T); t != nil { if p, _ := t.Underlying().(*Pointer); p != nil { obj, index, indirect = lookupFieldOrMethodImpl(p, false, pkg, name, false) if _, ok := obj.(*Func); ok { return nil, nil, false } return } } obj, index, indirect = lookupFieldOrMethodImpl(T, addressable, pkg, name, false) // If we didn't find anything and if we have a type parameter with a core type, // see if there is a matching field (but not a method, those need to be declared // explicitly in the constraint). If the constraint is a named pointer type (see // above), we are ok here because only fields are accepted as results. const enableTParamFieldLookup = false // see go.dev/issue/51576 if enableTParamFieldLookup && obj == nil && isTypeParam(T) { if t := coreType(T); t != nil { obj, index, indirect = lookupFieldOrMethodImpl(t, addressable, pkg, name, false) if _, ok := obj.(*Var); !ok { obj, index, indirect = nil, nil, false // accept fields (variables) only } } } return } // lookupFieldOrMethodImpl is the implementation of LookupFieldOrMethod. // Notably, in contrast to LookupFieldOrMethod, it won't find struct fields // in base types of defined (*Named) pointer types T. For instance, given // the declaration: // // type T *struct{f int} // // lookupFieldOrMethodImpl won't find the field f in the defined (*Named) type T // (methods on T are not permitted in the first place). // // Thus, lookupFieldOrMethodImpl should only be called by LookupFieldOrMethod // and missingMethod (the latter doesn't care about struct fields). // // If foldCase is true, method names are considered equal if they are equal // with case folding, irrespective of which package they are in. // // The resulting object may not be fully type-checked. func lookupFieldOrMethodImpl(T Type, addressable bool, pkg *Package, name string, foldCase bool) (obj Object, index []int, indirect bool) { // WARNING: The code in this function is extremely subtle - do not modify casually! if name == "_" { return // blank fields/methods are never found } // Importantly, we must not call under before the call to deref below (nor // does deref call under), as doing so could incorrectly result in finding // methods of the pointer base type when T is a (*Named) pointer type. typ, isPtr := deref(T) // *typ where typ is an interface (incl. a type parameter) has no methods. if isPtr { if _, ok := under(typ).(*Interface); ok { return } } // Start with typ as single entry at shallowest depth. current := []embeddedType{{typ, nil, isPtr, false}} // seen tracks named types that we have seen already, allocated lazily. // Used to avoid endless searches in case of recursive types. // // We must use a lookup on identity rather than a simple map[*Named]bool as // instantiated types may be identical but not equal. var seen instanceLookup // search current depth for len(current) > 0 { var next []embeddedType // embedded types found at current depth // look for (pkg, name) in all types at current depth for _, e := range current { typ := e.typ // If we have a named type, we may have associated methods. // Look for those first. if named := asNamed(typ); named != nil { if alt := seen.lookup(named); alt != nil { // We have seen this type before, at a more shallow depth // (note that multiples of this type at the current depth // were consolidated before). The type at that depth shadows // this same type at the current depth, so we can ignore // this one. continue } seen.add(named) // look for a matching attached method if i, m := named.lookupMethod(pkg, name, foldCase); m != nil { // potential match // caution: method may not have a proper signature yet index = concat(e.index, i) if obj != nil || e.multiples { return nil, index, false // collision } obj = m indirect = e.indirect continue // we can't have a matching field or interface method } } switch t := under(typ).(type) { case *Struct: // look for a matching field and collect embedded types for i, f := range t.fields { if f.sameId(pkg, name) { assert(f.typ != nil) index = concat(e.index, i) if obj != nil || e.multiples { return nil, index, false // collision } obj = f indirect = e.indirect continue // we can't have a matching interface method } // Collect embedded struct fields for searching the next // lower depth, but only if we have not seen a match yet // (if we have a match it is either the desired field or // we have a name collision on the same depth; in either // case we don't need to look further). // Embedded fields are always of the form T or *T where // T is a type name. If e.typ appeared multiple times at // this depth, f.typ appears multiple times at the next // depth. if obj == nil && f.embedded { typ, isPtr := deref(f.typ) // TODO(gri) optimization: ignore types that can't // have fields or methods (only Named, Struct, and // Interface types need to be considered). next = append(next, embeddedType{typ, concat(e.index, i), e.indirect || isPtr, e.multiples}) } } case *Interface: // look for a matching method (interface may be a type parameter) if i, m := t.typeSet().LookupMethod(pkg, name, foldCase); m != nil { assert(m.typ != nil) index = concat(e.index, i) if obj != nil || e.multiples { return nil, index, false // collision } obj = m indirect = e.indirect } } } if obj != nil { // found a potential match // spec: "A method call x.m() is valid if the method set of (the type of) x // contains m and the argument list can be assigned to the parameter // list of m. If x is addressable and &x's method set contains m, x.m() // is shorthand for (&x).m()". if f, _ := obj.(*Func); f != nil { // determine if method has a pointer receiver if f.hasPtrRecv() && !indirect && !addressable { return nil, nil, true // pointer/addressable receiver required } } return } current = consolidateMultiples(next) } return nil, nil, false // not found } // embeddedType represents an embedded type type embeddedType struct { typ Type index []int // embedded field indices, starting with index at depth 0 indirect bool // if set, there was a pointer indirection on the path to this field multiples bool // if set, typ appears multiple times at this depth } // consolidateMultiples collects multiple list entries with the same type // into a single entry marked as containing multiples. The result is the // consolidated list. func consolidateMultiples(list []embeddedType) []embeddedType { if len(list) <= 1 { return list // at most one entry - nothing to do } n := 0 // number of entries w/ unique type prev := make(map[Type]int) // index at which type was previously seen for _, e := range list { if i, found := lookupType(prev, e.typ); found { list[i].multiples = true // ignore this entry } else { prev[e.typ] = n list[n] = e n++ } } return list[:n] } func lookupType(m map[Type]int, typ Type) (int, bool) { // fast path: maybe the types are equal if i, found := m[typ]; found { return i, true } for t, i := range m { if Identical(t, typ) { return i, true } } return 0, false } type instanceLookup struct { // buf is used to avoid allocating the map m in the common case of a small // number of instances. buf [3]*Named m map[*Named][]*Named } func (l *instanceLookup) lookup(inst *Named) *Named { for _, t := range l.buf { if t != nil && Identical(inst, t) { return t } } for _, t := range l.m[inst.Origin()] { if Identical(inst, t) { return t } } return nil } func (l *instanceLookup) add(inst *Named) { for i, t := range l.buf { if t == nil { l.buf[i] = inst return } } if l.m == nil { l.m = make(map[*Named][]*Named) } insts := l.m[inst.Origin()] l.m[inst.Origin()] = append(insts, inst) } // MissingMethod returns (nil, false) if V implements T, otherwise it // returns a missing method required by T and whether it is missing or // just has the wrong type: either a pointer receiver or wrong signature. // // For non-interface types V, or if static is set, V implements T if all // methods of T are present in V. Otherwise (V is an interface and static // is not set), MissingMethod only checks that methods of T which are also // present in V have matching types (e.g., for a type assertion x.(T) where // x is of interface type V). func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool) { return (*Checker)(nil).missingMethod(V, T, static, Identical, nil) } // missingMethod is like MissingMethod but accepts a *Checker as receiver, // a comparator equivalent for type comparison, and a *string for error causes. // The receiver may be nil if missingMethod is invoked through an exported // API call (such as MissingMethod), i.e., when all methods have been type- // checked. // The underlying type of T must be an interface; T (rather than its under- // lying type) is used for better error messages (reported through *cause). // The comparator is used to compare signatures. // If a method is missing and cause is not nil, *cause describes the error. func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y Type) bool, cause *string) (method *Func, wrongType bool) { methods := under(T).(*Interface).typeSet().methods // T must be an interface if len(methods) == 0 { return nil, false } const ( ok = iota notFound wrongName unexported wrongSig ambigSel ptrRecv field ) state := ok var m *Func // method on T we're trying to implement var f *Func // method on V, if found (state is one of ok, wrongName, wrongSig) if u, _ := under(V).(*Interface); u != nil { tset := u.typeSet() for _, m = range methods { _, f = tset.LookupMethod(m.pkg, m.name, false) if f == nil { if !static { continue } state = notFound break } if !equivalent(f.typ, m.typ) { state = wrongSig break } } } else { for _, m = range methods { obj, index, indirect := lookupFieldOrMethodImpl(V, false, m.pkg, m.name, false) // check if m is ambiguous, on *V, or on V with case-folding if obj == nil { switch { case index != nil: state = ambigSel case indirect: state = ptrRecv default: state = notFound obj, _, _ = lookupFieldOrMethodImpl(V, false, m.pkg, m.name, true /* fold case */) f, _ = obj.(*Func) if f != nil { state = wrongName if f.name == m.name { // If the names are equal, f must be unexported // (otherwise the package wouldn't matter). state = unexported } } } break } // we must have a method (not a struct field) f, _ = obj.(*Func) if f == nil { state = field break } // methods may not have a fully set up signature yet if check != nil { check.objDecl(f, nil) } if !equivalent(f.typ, m.typ) { state = wrongSig break } } } if state == ok { return nil, false } if cause != nil { if f != nil { // This method may be formatted in funcString below, so must have a fully // set up signature. if check != nil { check.objDecl(f, nil) } } switch state { case notFound: switch { case isInterfacePtr(V): *cause = "(" + check.interfacePtrError(V) + ")" case isInterfacePtr(T): *cause = "(" + check.interfacePtrError(T) + ")" default: *cause = check.sprintf("(missing method %s)", m.Name()) } case wrongName: fs, ms := check.funcString(f, false), check.funcString(m, false) *cause = check.sprintf("(missing method %s)\n\t\thave %s\n\t\twant %s", m.Name(), fs, ms) case unexported: *cause = check.sprintf("(unexported method %s)", m.Name()) case wrongSig: fs, ms := check.funcString(f, false), check.funcString(m, false) if fs == ms { // Don't report "want Foo, have Foo". // Add package information to disambiguate (go.dev/issue/54258). fs, ms = check.funcString(f, true), check.funcString(m, true) } if fs == ms { // We still have "want Foo, have Foo". // This is most likely due to different type parameters with // the same name appearing in the instantiated signatures // (go.dev/issue/61685). // Rather than reporting this misleading error cause, for now // just point out that the method signature is incorrect. // TODO(gri) should find a good way to report the root cause *cause = check.sprintf("(wrong type for method %s)", m.Name()) break } *cause = check.sprintf("(wrong type for method %s)\n\t\thave %s\n\t\twant %s", m.Name(), fs, ms) case ambigSel: *cause = check.sprintf("(ambiguous selector %s.%s)", V, m.Name()) case ptrRecv: *cause = check.sprintf("(method %s has pointer receiver)", m.Name()) case field: *cause = check.sprintf("(%s.%s is a field, not a method)", V, m.Name()) default: unreachable() } } return m, state == wrongSig || state == ptrRecv } func isInterfacePtr(T Type) bool { p, _ := under(T).(*Pointer) return p != nil && IsInterface(p.base) } // check may be nil. func (check *Checker) interfacePtrError(T Type) string { assert(isInterfacePtr(T)) if p, _ := under(T).(*Pointer); isTypeParam(p.base) { return check.sprintf("type %s is pointer to type parameter, not type parameter", T) } return check.sprintf("type %s is pointer to interface, not interface", T) } // funcString returns a string of the form name + signature for f. // check may be nil. func (check *Checker) funcString(f *Func, pkgInfo bool) string { buf := bytes.NewBufferString(f.name) var qf Qualifier if check != nil && !pkgInfo { qf = check.qualifier } w := newTypeWriter(buf, qf) w.pkgInfo = pkgInfo w.paramNames = false w.signature(f.typ.(*Signature)) return buf.String() } // assertableTo reports whether a value of type V can be asserted to have type T. // The receiver may be nil if assertableTo is invoked through an exported API call // (such as AssertableTo), i.e., when all methods have been type-checked. // The underlying type of V must be an interface. // If the result is false and cause is not nil, *cause describes the error. // TODO(gri) replace calls to this function with calls to newAssertableTo. func (check *Checker) assertableTo(V, T Type, cause *string) bool { // no static check is required if T is an interface // spec: "If T is an interface type, x.(T) asserts that the // dynamic type of x implements the interface T." if IsInterface(T) { return true } // TODO(gri) fix this for generalized interfaces m, _ := check.missingMethod(T, V, false, Identical, cause) return m == nil } // newAssertableTo reports whether a value of type V can be asserted to have type T. // It also implements behavior for interfaces that currently are only permitted // in constraint position (we have not yet defined that behavior in the spec). // The underlying type of V must be an interface. // If the result is false and cause is not nil, *cause is set to the error cause. func (check *Checker) newAssertableTo(pos syntax.Pos, V, T Type, cause *string) bool { // no static check is required if T is an interface // spec: "If T is an interface type, x.(T) asserts that the // dynamic type of x implements the interface T." if IsInterface(T) { return true } return check.implements(pos, T, V, false, cause) } // deref dereferences typ if it is a *Pointer (but not a *Named type // with an underlying pointer type!) and returns its base and true. // Otherwise it returns (typ, false). func deref(typ Type) (Type, bool) { if p, _ := Unalias(typ).(*Pointer); p != nil { // p.base should never be nil, but be conservative if p.base == nil { if debug { panic("pointer with nil base type (possibly due to an invalid cyclic declaration)") } return Typ[Invalid], true } return p.base, true } return typ, false } // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a // (named or unnamed) struct and returns its base. Otherwise it returns typ. func derefStructPtr(typ Type) Type { if p, _ := under(typ).(*Pointer); p != nil { if _, ok := under(p.base).(*Struct); ok { return p.base } } return typ } // concat returns the result of concatenating list and i. // The result does not share its underlying array with list. func concat(list []int, i int) []int { var t []int t = append(t, list...) return append(t, i) } // fieldIndex returns the index for the field with matching package and name, or a value < 0. func fieldIndex(fields []*Var, pkg *Package, name string) int { if name != "_" { for i, f := range fields { if f.sameId(pkg, name) { return i } } } return -1 } // lookupMethod returns the index of and method with matching package and name, or (-1, nil). // If foldCase is true, method names are considered equal if they are equal with case folding // and their packages are ignored (e.g., pkg1.m, pkg1.M, pkg2.m, and pkg2.M are all equal). func lookupMethod(methods []*Func, pkg *Package, name string, foldCase bool) (int, *Func) { if name != "_" { for i, m := range methods { if m.sameId(pkg, name) || foldCase && strings.EqualFold(m.name, name) { return i, m } } } return -1, nil } PK ! �Y y labels.gonu �[��� // Copyright 2013 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 types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" ) // labels checks correct label use in body. func (check *Checker) labels(body *syntax.BlockStmt) { // set of all labels in this body all := NewScope(nil, body.Pos(), syntax.EndPos(body), "label") fwdJumps := check.blockBranches(all, nil, nil, body.List) // If there are any forward jumps left, no label was found for // the corresponding goto statements. Either those labels were // never defined, or they are inside blocks and not reachable // for the respective gotos. for _, jmp := range fwdJumps { var msg string var code Code name := jmp.Label.Value if alt := all.Lookup(name); alt != nil { msg = "goto %s jumps into block" alt.(*Label).used = true // avoid another error code = JumpIntoBlock } else { msg = "label %s not declared" code = UndeclaredLabel } check.errorf(jmp.Label, code, msg, name) } // spec: "It is illegal to define a label that is never used." for name, obj := range all.elems { obj = resolve(name, obj) if lbl := obj.(*Label); !lbl.used { check.softErrorf(lbl.pos, UnusedLabel, "label %s declared and not used", lbl.name) } } } // A block tracks label declarations in a block and its enclosing blocks. type block struct { parent *block // enclosing block lstmt *syntax.LabeledStmt // labeled statement to which this block belongs, or nil labels map[string]*syntax.LabeledStmt // allocated lazily } // insert records a new label declaration for the current block. // The label must not have been declared before in any block. func (b *block) insert(s *syntax.LabeledStmt) { name := s.Label.Value if debug { assert(b.gotoTarget(name) == nil) } labels := b.labels if labels == nil { labels = make(map[string]*syntax.LabeledStmt) b.labels = labels } labels[name] = s } // gotoTarget returns the labeled statement in the current // or an enclosing block with the given label name, or nil. func (b *block) gotoTarget(name string) *syntax.LabeledStmt { for s := b; s != nil; s = s.parent { if t := s.labels[name]; t != nil { return t } } return nil } // enclosingTarget returns the innermost enclosing labeled // statement with the given label name, or nil. func (b *block) enclosingTarget(name string) *syntax.LabeledStmt { for s := b; s != nil; s = s.parent { if t := s.lstmt; t != nil && t.Label.Value == name { return t } } return nil } // blockBranches processes a block's statement list and returns the set of outgoing forward jumps. // all is the scope of all declared labels, parent the set of labels declared in the immediately // enclosing block, and lstmt is the labeled statement this block is associated with (or nil). func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *syntax.LabeledStmt, list []syntax.Stmt) []*syntax.BranchStmt { b := &block{parent, lstmt, nil} var ( varDeclPos syntax.Pos fwdJumps, badJumps []*syntax.BranchStmt ) // All forward jumps jumping over a variable declaration are possibly // invalid (they may still jump out of the block and be ok). // recordVarDecl records them for the given position. recordVarDecl := func(pos syntax.Pos) { varDeclPos = pos badJumps = append(badJumps[:0], fwdJumps...) // copy fwdJumps to badJumps } jumpsOverVarDecl := func(jmp *syntax.BranchStmt) bool { if varDeclPos.IsKnown() { for _, bad := range badJumps { if jmp == bad { return true } } } return false } var stmtBranches func(syntax.Stmt) stmtBranches = func(s syntax.Stmt) { switch s := s.(type) { case *syntax.DeclStmt: for _, d := range s.DeclList { if d, _ := d.(*syntax.VarDecl); d != nil { recordVarDecl(d.Pos()) } } case *syntax.LabeledStmt: // declare non-blank label if name := s.Label.Value; name != "_" { lbl := NewLabel(s.Label.Pos(), check.pkg, name) if alt := all.Insert(lbl); alt != nil { var err error_ err.code = DuplicateLabel err.soft = true err.errorf(lbl.pos, "label %s already declared", name) err.recordAltDecl(alt) check.report(&err) // ok to continue } else { b.insert(s) check.recordDef(s.Label, lbl) } // resolve matching forward jumps and remove them from fwdJumps i := 0 for _, jmp := range fwdJumps { if jmp.Label.Value == name { // match lbl.used = true check.recordUse(jmp.Label, lbl) if jumpsOverVarDecl(jmp) { check.softErrorf( jmp.Label, JumpOverDecl, "goto %s jumps over variable declaration at line %d", name, varDeclPos.Line(), ) // ok to continue } } else { // no match - record new forward jump fwdJumps[i] = jmp i++ } } fwdJumps = fwdJumps[:i] lstmt = s } stmtBranches(s.Stmt) case *syntax.BranchStmt: if s.Label == nil { return // checked in 1st pass (check.stmt) } // determine and validate target name := s.Label.Value switch s.Tok { case syntax.Break: // spec: "If there is a label, it must be that of an enclosing // "for", "switch", or "select" statement, and that is the one // whose execution terminates." valid := false if t := b.enclosingTarget(name); t != nil { switch t.Stmt.(type) { case *syntax.SwitchStmt, *syntax.SelectStmt, *syntax.ForStmt: valid = true } } if !valid { check.errorf(s.Label, MisplacedLabel, "invalid break label %s", name) return } case syntax.Continue: // spec: "If there is a label, it must be that of an enclosing // "for" statement, and that is the one whose execution advances." valid := false if t := b.enclosingTarget(name); t != nil { switch t.Stmt.(type) { case *syntax.ForStmt: valid = true } } if !valid { check.errorf(s.Label, MisplacedLabel, "invalid continue label %s", name) return } case syntax.Goto: if b.gotoTarget(name) == nil { // label may be declared later - add branch to forward jumps fwdJumps = append(fwdJumps, s) return } default: check.errorf(s, InvalidSyntaxTree, "branch statement: %s %s", s.Tok, name) return } // record label use obj := all.Lookup(name) obj.(*Label).used = true check.recordUse(s.Label, obj) case *syntax.AssignStmt: if s.Op == syntax.Def { recordVarDecl(s.Pos()) } case *syntax.BlockStmt: // Unresolved forward jumps inside the nested block // become forward jumps in the current block. fwdJumps = append(fwdJumps, check.blockBranches(all, b, lstmt, s.List)...) case *syntax.IfStmt: stmtBranches(s.Then) if s.Else != nil { stmtBranches(s.Else) } case *syntax.SwitchStmt: b := &block{b, lstmt, nil} for _, s := range s.Body { fwdJumps = append(fwdJumps, check.blockBranches(all, b, nil, s.Body)...) } case *syntax.SelectStmt: b := &block{b, lstmt, nil} for _, s := range s.Body { fwdJumps = append(fwdJumps, check.blockBranches(all, b, nil, s.Body)...) } case *syntax.ForStmt: stmtBranches(s.Body) } } for _, s := range list { stmtBranches(s) } return fwdJumps } PK ! v� �� � package.gonu �[��� // Copyright 2013 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 types2 import ( "fmt" ) // A Package describes a Go package. type Package struct { path string name string scope *Scope imports []*Package complete bool fake bool // scope lookup errors are silently dropped if package is fake (internal use only) cgo bool // uses of this package will be rewritten into uses of declarations from _cgo_gotypes.go goVersion string // minimum Go version required for package (by Config.GoVersion, typically from go.mod) } // NewPackage returns a new Package for the given package path and name. // The package is not complete and contains no explicit imports. func NewPackage(path, name string) *Package { scope := NewScope(Universe, nopos, nopos, fmt.Sprintf("package %q", path)) return &Package{path: path, name: name, scope: scope} } // Path returns the package path. func (pkg *Package) Path() string { return pkg.path } // Name returns the package name. func (pkg *Package) Name() string { return pkg.name } // SetName sets the package name. func (pkg *Package) SetName(name string) { pkg.name = name } // GoVersion returns the minimum Go version required by this package. // If the minimum version is unknown, GoVersion returns the empty string. // Individual source files may specify a different minimum Go version, // as reported in the [go/ast.File.GoVersion] field. func (pkg *Package) GoVersion() string { return pkg.goVersion } // Scope returns the (complete or incomplete) package scope // holding the objects declared at package level (TypeNames, // Consts, Vars, and Funcs). // For a nil pkg receiver, Scope returns the Universe scope. func (pkg *Package) Scope() *Scope { if pkg != nil { return pkg.scope } return Universe } // A package is complete if its scope contains (at least) all // exported objects; otherwise it is incomplete. func (pkg *Package) Complete() bool { return pkg.complete } // MarkComplete marks a package as complete. func (pkg *Package) MarkComplete() { pkg.complete = true } // Imports returns the list of packages directly imported by // pkg; the list is in source order. // // If pkg was loaded from export data, Imports includes packages that // provide package-level objects referenced by pkg. This may be more or // less than the set of packages directly imported by pkg's source code. // // If pkg uses cgo and the FakeImportC configuration option // was enabled, the imports list may contain a fake "C" package. func (pkg *Package) Imports() []*Package { return pkg.imports } // SetImports sets the list of explicitly imported packages to list. // It is the caller's responsibility to make sure list elements are unique. func (pkg *Package) SetImports(list []*Package) { pkg.imports = list } func (pkg *Package) String() string { return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path) } PK ! %P�,- - alias.gonu �[��� // Copyright 2023 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 types2 import "fmt" // An Alias represents an alias type. // Whether or not Alias types are created is controlled by the // gotypesalias setting with the GODEBUG environment variable. // For gotypesalias=1, alias declarations produce an Alias type. // Otherwise, the alias information is only in the type name, // which points directly to the actual (aliased) type. type Alias struct { obj *TypeName // corresponding declared alias object fromRHS Type // RHS of type alias declaration; may be an alias actual Type // actual (aliased) type; never an alias } // NewAlias creates a new Alias type with the given type name and rhs. // rhs must not be nil. func NewAlias(obj *TypeName, rhs Type) *Alias { alias := (*Checker)(nil).newAlias(obj, rhs) // Ensure that alias.actual is set (#65455). unalias(alias) return alias } func (a *Alias) Obj() *TypeName { return a.obj } func (a *Alias) Underlying() Type { return unalias(a).Underlying() } func (a *Alias) String() string { return TypeString(a, nil) } // Type accessors // Unalias returns t if it is not an alias type; // otherwise it follows t's alias chain until it // reaches a non-alias type which is then returned. // Consequently, the result is never an alias type. func Unalias(t Type) Type { if a0, _ := t.(*Alias); a0 != nil { return unalias(a0) } return t } func unalias(a0 *Alias) Type { if a0.actual != nil { return a0.actual } var t Type for a := a0; a != nil; a, _ = t.(*Alias) { t = a.fromRHS } if t == nil { panic(fmt.Sprintf("non-terminated alias %s", a0.obj.name)) } a0.actual = t return t } // asNamed returns t as *Named if that is t's // actual type. It returns nil otherwise. func asNamed(t Type) *Named { n, _ := Unalias(t).(*Named) return n } // newAlias creates a new Alias type with the given type name and rhs. // rhs must not be nil. func (check *Checker) newAlias(obj *TypeName, rhs Type) *Alias { assert(rhs != nil) a := &Alias{obj, rhs, nil} if obj.typ == nil { obj.typ = a } // Ensure that a.actual is set at the end of type checking. if check != nil { check.needsCleanup(a) } return a } func (a *Alias) cleanup() { Unalias(a) } PK ! �^8� union.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" ) // ---------------------------------------------------------------------------- // API // A Union represents a union of terms embedded in an interface. type Union struct { terms []*Term // list of syntactical terms (not a canonicalized termlist) } // NewUnion returns a new Union type with the given terms. // It is an error to create an empty union; they are syntactically not possible. func NewUnion(terms []*Term) *Union { if len(terms) == 0 { panic("empty union") } return &Union{terms} } func (u *Union) Len() int { return len(u.terms) } func (u *Union) Term(i int) *Term { return u.terms[i] } func (u *Union) Underlying() Type { return u } func (u *Union) String() string { return TypeString(u, nil) } // A Term represents a term in a Union. type Term term // NewTerm returns a new union term. func NewTerm(tilde bool, typ Type) *Term { return &Term{tilde, typ} } func (t *Term) Tilde() bool { return t.tilde } func (t *Term) Type() Type { return t.typ } func (t *Term) String() string { return (*term)(t).String() } // ---------------------------------------------------------------------------- // Implementation // Avoid excessive type-checking times due to quadratic termlist operations. const maxTermCount = 100 // parseUnion parses uexpr as a union of expressions. // The result is a Union type, or Typ[Invalid] for some errors. func parseUnion(check *Checker, uexpr syntax.Expr) Type { blist, tlist := flattenUnion(nil, uexpr) assert(len(blist) == len(tlist)-1) var terms []*Term var u Type for i, x := range tlist { term := parseTilde(check, x) if len(tlist) == 1 && !term.tilde { // Single type. Ok to return early because all relevant // checks have been performed in parseTilde (no need to // run through term validity check below). return term.typ // typ already recorded through check.typ in parseTilde } if len(terms) >= maxTermCount { if isValid(u) { check.errorf(x, InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) u = Typ[Invalid] } } else { terms = append(terms, term) u = &Union{terms} } if i > 0 { check.recordTypeAndValue(blist[i-1], typexpr, u, nil) } } if !isValid(u) { return u } // Check validity of terms. // Do this check later because it requires types to be set up. // Note: This is a quadratic algorithm, but unions tend to be short. check.later(func() { for i, t := range terms { if !isValid(t.typ) { continue } u := under(t.typ) f, _ := u.(*Interface) if t.tilde { if f != nil { check.errorf(tlist[i], InvalidUnion, "invalid use of ~ (%s is an interface)", t.typ) continue // don't report another error for t } if !Identical(u, t.typ) { check.errorf(tlist[i], InvalidUnion, "invalid use of ~ (underlying type of %s is %s)", t.typ, u) continue } } // Stand-alone embedded interfaces are ok and are handled by the single-type case // in the beginning. Embedded interfaces with tilde are excluded above. If we reach // here, we must have at least two terms in the syntactic term list (but not necessarily // in the term list of the union's type set). if f != nil { tset := f.typeSet() switch { case tset.NumMethods() != 0: check.errorf(tlist[i], InvalidUnion, "cannot use %s in union (%s contains methods)", t, t) case t.typ == universeComparable.Type(): check.error(tlist[i], InvalidUnion, "cannot use comparable in union") case tset.comparable: check.errorf(tlist[i], InvalidUnion, "cannot use %s in union (%s embeds comparable)", t, t) } continue // terms with interface types are not subject to the no-overlap rule } // Report overlapping (non-disjoint) terms such as // a|a, a|~a, ~a|~a, and ~a|A (where under(A) == a). if j := overlappingTerm(terms[:i], t); j >= 0 { check.softErrorf(tlist[i], InvalidUnion, "overlapping terms %s and %s", t, terms[j]) } } }).describef(uexpr, "check term validity %s", uexpr) return u } func parseTilde(check *Checker, tx syntax.Expr) *Term { x := tx var tilde bool if op, _ := x.(*syntax.Operation); op != nil && op.Op == syntax.Tilde { x = op.X tilde = true } typ := check.typ(x) // Embedding stand-alone type parameters is not permitted (go.dev/issue/47127). // We don't need this restriction anymore if we make the underlying type of a type // parameter its constraint interface: if we embed a lone type parameter, we will // simply use its underlying type (like we do for other named, embedded interfaces), // and since the underlying type is an interface the embedding is well defined. if isTypeParam(typ) { if tilde { check.errorf(x, MisplacedTypeParam, "type in term %s cannot be a type parameter", tx) } else { check.error(x, MisplacedTypeParam, "term cannot be a type parameter") } typ = Typ[Invalid] } term := NewTerm(tilde, typ) if tilde { check.recordTypeAndValue(tx, typexpr, &Union{[]*Term{term}}, nil) } return term } // overlappingTerm reports the index of the term x in terms which is // overlapping (not disjoint) from y. The result is < 0 if there is no // such term. The type of term y must not be an interface, and terms // with an interface type are ignored in the terms list. func overlappingTerm(terms []*Term, y *Term) int { assert(!IsInterface(y.typ)) for i, x := range terms { if IsInterface(x.typ) { continue } // disjoint requires non-nil, non-top arguments, // and non-interface types as term types. if debug { if x == nil || x.typ == nil || y == nil || y.typ == nil { panic("empty or top union term") } } if !(*term)(x).disjoint((*term)(y)) { return i } } return -1 } // flattenUnion walks a union type expression of the form A | B | C | ..., // extracting both the binary exprs (blist) and leaf types (tlist). func flattenUnion(list []syntax.Expr, x syntax.Expr) (blist, tlist []syntax.Expr) { if o, _ := x.(*syntax.Operation); o != nil && o.Op == syntax.Or { blist, tlist = flattenUnion(list, o.X) blist = append(blist, o) x = o.Y } return blist, append(tlist, x) } PK ! �e~�,p ,p issues_test.gonu �[��� // Copyright 2013 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. // This file implements tests for various issues. package types2_test import ( "cmd/compile/internal/syntax" "fmt" "internal/testenv" "regexp" "sort" "strings" "testing" . "cmd/compile/internal/types2" ) func TestIssue5770(t *testing.T) { _, err := typecheck(`package p; type S struct{T}`, nil, nil) const want = "undefined: T" if err == nil || !strings.Contains(err.Error(), want) { t.Errorf("got: %v; want: %s", err, want) } } func TestIssue5849(t *testing.T) { src := ` package p var ( s uint _ = uint8(8) _ = uint16(16) << s _ = uint32(32 << s) _ = uint64(64 << s + s) _ = (interface{})("foo") _ = (interface{})(nil) )` types := make(map[syntax.Expr]TypeAndValue) mustTypecheck(src, nil, &Info{Types: types}) for x, tv := range types { var want Type switch x := x.(type) { case *syntax.BasicLit: switch x.Value { case `8`: want = Typ[Uint8] case `16`: want = Typ[Uint16] case `32`: want = Typ[Uint32] case `64`: want = Typ[Uint] // because of "+ s", s is of type uint case `"foo"`: want = Typ[String] } case *syntax.Name: if x.Value == "nil" { want = NewInterfaceType(nil, nil) // interface{} (for now, go/types types this as "untyped nil") } } if want != nil && !Identical(tv.Type, want) { t.Errorf("got %s; want %s", tv.Type, want) } } } func TestIssue6413(t *testing.T) { src := ` package p func f() int { defer f() go f() return 0 } ` types := make(map[syntax.Expr]TypeAndValue) mustTypecheck(src, nil, &Info{Types: types}) want := Typ[Int] n := 0 for x, tv := range types { if _, ok := x.(*syntax.CallExpr); ok { if tv.Type != want { t.Errorf("%s: got %s; want %s", x.Pos(), tv.Type, want) } n++ } } if n != 2 { t.Errorf("got %d CallExprs; want 2", n) } } func TestIssue7245(t *testing.T) { src := ` package p func (T) m() (res bool) { return } type T struct{} // receiver type after method declaration ` f := mustParse(src) var conf Config defs := make(map[*syntax.Name]Object) _, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, &Info{Defs: defs}) if err != nil { t.Fatal(err) } m := f.DeclList[0].(*syntax.FuncDecl) res1 := defs[m.Name].(*Func).Type().(*Signature).Results().At(0) res2 := defs[m.Type.ResultList[0].Name].(*Var) if res1 != res2 { t.Errorf("got %s (%p) != %s (%p)", res1, res2, res1, res2) } } // This tests that uses of existing vars on the LHS of an assignment // are Uses, not Defs; and also that the (illegal) use of a non-var on // the LHS of an assignment is a Use nonetheless. func TestIssue7827(t *testing.T) { const src = ` package p func _() { const w = 1 // defs w x, y := 2, 3 // defs x, y w, x, z := 4, 5, 6 // uses w, x, defs z; error: cannot assign to w _, _, _ = x, y, z // uses x, y, z } ` const want = `L3 defs func p._() L4 defs const w untyped int L5 defs var x int L5 defs var y int L6 defs var z int L6 uses const w untyped int L6 uses var x int L7 uses var x int L7 uses var y int L7 uses var z int` // don't abort at the first error conf := Config{Error: func(err error) { t.Log(err) }} defs := make(map[*syntax.Name]Object) uses := make(map[*syntax.Name]Object) _, err := typecheck(src, &conf, &Info{Defs: defs, Uses: uses}) if s := err.Error(); !strings.HasSuffix(s, "cannot assign to w") { t.Errorf("Check: unexpected error: %s", s) } var facts []string for id, obj := range defs { if obj != nil { fact := fmt.Sprintf("L%d defs %s", id.Pos().Line(), obj) facts = append(facts, fact) } } for id, obj := range uses { fact := fmt.Sprintf("L%d uses %s", id.Pos().Line(), obj) facts = append(facts, fact) } sort.Strings(facts) got := strings.Join(facts, "\n") if got != want { t.Errorf("Unexpected defs/uses\ngot:\n%s\nwant:\n%s", got, want) } } // This tests that the package associated with the types2.Object.Pkg method // is the type's package independent of the order in which the imports are // listed in the sources src1, src2 below. // The actual issue is in go/internal/gcimporter which has a corresponding // test; we leave this test here to verify correct behavior at the go/types // level. func TestIssue13898(t *testing.T) { testenv.MustHaveGoBuild(t) const src0 = ` package main import "go/types" func main() { var info types.Info for _, obj := range info.Uses { _ = obj.Pkg() } } ` // like src0, but also imports go/importer const src1 = ` package main import ( "go/types" _ "go/importer" ) func main() { var info types.Info for _, obj := range info.Uses { _ = obj.Pkg() } } ` // like src1 but with different import order // (used to fail with this issue) const src2 = ` package main import ( _ "go/importer" "go/types" ) func main() { var info types.Info for _, obj := range info.Uses { _ = obj.Pkg() } } ` f := func(test, src string) { info := &Info{Uses: make(map[*syntax.Name]Object)} mustTypecheck(src, nil, info) var pkg *Package count := 0 for id, obj := range info.Uses { if id.Value == "Pkg" { pkg = obj.Pkg() count++ } } if count != 1 { t.Fatalf("%s: got %d entries named Pkg; want 1", test, count) } if pkg.Name() != "types" { t.Fatalf("%s: got %v; want package types2", test, pkg) } } f("src0", src0) f("src1", src1) f("src2", src2) } func TestIssue22525(t *testing.T) { const src = `package p; func f() { var a, b, c, d, e int }` got := "\n" conf := Config{Error: func(err error) { got += err.Error() + "\n" }} typecheck(src, &conf, nil) // do not crash want := ` p:1:27: a declared and not used p:1:30: b declared and not used p:1:33: c declared and not used p:1:36: d declared and not used p:1:39: e declared and not used ` if got != want { t.Errorf("got: %swant: %s", got, want) } } func TestIssue25627(t *testing.T) { const prefix = `package p; import "unsafe"; type P *struct{}; type I interface{}; type T ` // The src strings (without prefix) are constructed such that the number of semicolons // plus one corresponds to the number of fields expected in the respective struct. for _, src := range []string{ `struct { x Missing }`, `struct { Missing }`, `struct { *Missing }`, `struct { unsafe.Pointer }`, `struct { P }`, `struct { *I }`, `struct { a int; b Missing; *Missing }`, } { f := mustParse(prefix + src) conf := Config{Importer: defaultImporter(), Error: func(err error) {}} info := &Info{Types: make(map[syntax.Expr]TypeAndValue)} _, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, info) if err != nil { if _, ok := err.(Error); !ok { t.Fatal(err) } } syntax.Inspect(f, func(n syntax.Node) bool { if decl, _ := n.(*syntax.TypeDecl); decl != nil { if tv, ok := info.Types[decl.Type]; ok && decl.Name.Value == "T" { want := strings.Count(src, ";") + 1 if got := tv.Type.(*Struct).NumFields(); got != want { t.Errorf("%s: got %d fields; want %d", src, got, want) } } } return true }) } } func TestIssue28005(t *testing.T) { // method names must match defining interface name for this test // (see last comment in this function) sources := [...]string{ "package p; type A interface{ A() }", "package p; type B interface{ B() }", "package p; type X interface{ A; B }", } // compute original file ASTs var orig [len(sources)]*syntax.File for i, src := range sources { orig[i] = mustParse(src) } // run the test for all order permutations of the incoming files for _, perm := range [][len(sources)]int{ {0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {2, 1, 0}, } { // create file order permutation files := make([]*syntax.File, len(sources)) for i := range perm { files[i] = orig[perm[i]] } // type-check package with given file order permutation var conf Config info := &Info{Defs: make(map[*syntax.Name]Object)} _, err := conf.Check("", files, info) if err != nil { t.Fatal(err) } // look for interface object X var obj Object for name, def := range info.Defs { if name.Value == "X" { obj = def break } } if obj == nil { t.Fatal("object X not found") } iface := obj.Type().Underlying().(*Interface) // object X must be an interface // Each iface method m is embedded; and m's receiver base type name // must match the method's name per the choice in the source file. for i := 0; i < iface.NumMethods(); i++ { m := iface.Method(i) recvName := m.Type().(*Signature).Recv().Type().(*Named).Obj().Name() if recvName != m.Name() { t.Errorf("perm %v: got recv %s; want %s", perm, recvName, m.Name()) } } } } func TestIssue28282(t *testing.T) { // create type interface { error } et := Universe.Lookup("error").Type() it := NewInterfaceType(nil, []Type{et}) // verify that after completing the interface, the embedded method remains unchanged // (interfaces are "completed" lazily now, so the completion happens implicitly when // accessing Method(0)) want := et.Underlying().(*Interface).Method(0) got := it.Method(0) if got != want { t.Fatalf("%s.Method(0): got %q (%p); want %q (%p)", it, got, got, want, want) } // verify that lookup finds the same method in both interfaces (redundant check) obj, _, _ := LookupFieldOrMethod(et, false, nil, "Error") if obj != want { t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", et, obj, obj, want, want) } obj, _, _ = LookupFieldOrMethod(it, false, nil, "Error") if obj != want { t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", it, obj, obj, want, want) } } func TestIssue29029(t *testing.T) { f1 := mustParse(`package p; type A interface { M() }`) f2 := mustParse(`package p; var B interface { A }`) // printInfo prints the *Func definitions recorded in info, one *Func per line. printInfo := func(info *Info) string { var buf strings.Builder for _, obj := range info.Defs { if fn, ok := obj.(*Func); ok { fmt.Fprintln(&buf, fn) } } return buf.String() } // The *Func (method) definitions for package p must be the same // independent on whether f1 and f2 are type-checked together, or // incrementally. // type-check together var conf Config info := &Info{Defs: make(map[*syntax.Name]Object)} check := NewChecker(&conf, NewPackage("", "p"), info) if err := check.Files([]*syntax.File{f1, f2}); err != nil { t.Fatal(err) } want := printInfo(info) // type-check incrementally info = &Info{Defs: make(map[*syntax.Name]Object)} check = NewChecker(&conf, NewPackage("", "p"), info) if err := check.Files([]*syntax.File{f1}); err != nil { t.Fatal(err) } if err := check.Files([]*syntax.File{f2}); err != nil { t.Fatal(err) } got := printInfo(info) if got != want { t.Errorf("\ngot : %swant: %s", got, want) } } func TestIssue34151(t *testing.T) { const asrc = `package a; type I interface{ M() }; type T struct { F interface { I } }` const bsrc = `package b; import "a"; type T struct { F interface { a.I } }; var _ = a.T(T{})` a := mustTypecheck(asrc, nil, nil) conf := Config{Importer: importHelper{pkg: a}} mustTypecheck(bsrc, &conf, nil) } type importHelper struct { pkg *Package fallback Importer } func (h importHelper) Import(path string) (*Package, error) { if path == h.pkg.Path() { return h.pkg, nil } if h.fallback == nil { return nil, fmt.Errorf("got package path %q; want %q", path, h.pkg.Path()) } return h.fallback.Import(path) } // TestIssue34921 verifies that we don't update an imported type's underlying // type when resolving an underlying type. Specifically, when determining the // underlying type of b.T (which is the underlying type of a.T, which is int) // we must not set the underlying type of a.T again since that would lead to // a race condition if package b is imported elsewhere, in a package that is // concurrently type-checked. func TestIssue34921(t *testing.T) { defer func() { if r := recover(); r != nil { t.Error(r) } }() var sources = []string{ `package a; type T int`, `package b; import "a"; type T a.T`, } var pkg *Package for _, src := range sources { conf := Config{Importer: importHelper{pkg: pkg}} pkg = mustTypecheck(src, &conf, nil) // pkg imported by the next package in this test } } func TestIssue43088(t *testing.T) { // type T1 struct { // _ T2 // } // // type T2 struct { // _ struct { // _ T2 // } // } n1 := NewTypeName(nopos, nil, "T1", nil) T1 := NewNamed(n1, nil, nil) n2 := NewTypeName(nopos, nil, "T2", nil) T2 := NewNamed(n2, nil, nil) s1 := NewStruct([]*Var{NewField(nopos, nil, "_", T2, false)}, nil) T1.SetUnderlying(s1) s2 := NewStruct([]*Var{NewField(nopos, nil, "_", T2, false)}, nil) s3 := NewStruct([]*Var{NewField(nopos, nil, "_", s2, false)}, nil) T2.SetUnderlying(s3) // These calls must terminate (no endless recursion). Comparable(T1) Comparable(T2) } func TestIssue44515(t *testing.T) { typ := Unsafe.Scope().Lookup("Pointer").Type() got := TypeString(typ, nil) want := "unsafe.Pointer" if got != want { t.Errorf("got %q; want %q", got, want) } qf := func(pkg *Package) string { if pkg == Unsafe { return "foo" } return "" } got = TypeString(typ, qf) want = "foo.Pointer" if got != want { t.Errorf("got %q; want %q", got, want) } } func TestIssue43124(t *testing.T) { // TODO(rFindley) move this to testdata by enhancing support for importing. testenv.MustHaveGoBuild(t) // The go command is needed for the importer to determine the locations of stdlib .a files. // All involved packages have the same name (template). Error messages should // disambiguate between text/template and html/template by printing the full // path. const ( asrc = `package a; import "text/template"; func F(template.Template) {}; func G(int) {}` bsrc = ` package b import ( "a" "html/template" ) func _() { // Packages should be fully qualified when there is ambiguity within the // error string itself. a.F(template /* ERRORx "cannot use.*html/template.* as .*text/template" */ .Template{}) } ` csrc = ` package c import ( "a" "fmt" "html/template" ) // go.dev/issue/46905: make sure template is not the first package qualified. var _ fmt.Stringer = 1 // ERRORx "cannot use 1.*as fmt\\.Stringer" // Packages should be fully qualified when there is ambiguity in reachable // packages. In this case both a (and for that matter html/template) import // text/template. func _() { a.G(template /* ERRORx "cannot use .*html/template.*Template" */ .Template{}) } ` tsrc = ` package template import "text/template" type T int // Verify that the current package name also causes disambiguation. var _ T = template /* ERRORx "cannot use.*text/template.* as T value" */.Template{} ` ) a := mustTypecheck(asrc, nil, nil) imp := importHelper{pkg: a, fallback: defaultImporter()} withImporter := func(cfg *Config) { cfg.Importer = imp } testFiles(t, []string{"b.go"}, [][]byte{[]byte(bsrc)}, 0, false, withImporter) testFiles(t, []string{"c.go"}, [][]byte{[]byte(csrc)}, 0, false, withImporter) testFiles(t, []string{"t.go"}, [][]byte{[]byte(tsrc)}, 0, false, withImporter) } func TestIssue50646(t *testing.T) { anyType := Universe.Lookup("any").Type() comparableType := Universe.Lookup("comparable").Type() if !Comparable(anyType) { t.Error("any is not a comparable type") } if !Comparable(comparableType) { t.Error("comparable is not a comparable type") } if Implements(anyType, comparableType.Underlying().(*Interface)) { t.Error("any implements comparable") } if !Implements(comparableType, anyType.(*Interface)) { t.Error("comparable does not implement any") } if AssignableTo(anyType, comparableType) { t.Error("any assignable to comparable") } if !AssignableTo(comparableType, anyType) { t.Error("comparable not assignable to any") } } func TestIssue55030(t *testing.T) { // makeSig makes the signature func(typ...) makeSig := func(typ Type) { par := NewVar(nopos, nil, "", typ) params := NewTuple(par) NewSignatureType(nil, nil, nil, params, nil, true) } // makeSig must not panic for the following (example) types: // []int makeSig(NewSlice(Typ[Int])) // string makeSig(Typ[String]) // P where P's core type is string { P := NewTypeName(nopos, nil, "P", nil) // [P string] makeSig(NewTypeParam(P, NewInterfaceType(nil, []Type{Typ[String]}))) } // P where P's core type is an (unnamed) slice { P := NewTypeName(nopos, nil, "P", nil) // [P []int] makeSig(NewTypeParam(P, NewInterfaceType(nil, []Type{NewSlice(Typ[Int])}))) } // P where P's core type is bytestring (i.e., string or []byte) { t1 := NewTerm(true, Typ[String]) // ~string t2 := NewTerm(false, NewSlice(Typ[Byte])) // []byte u := NewUnion([]*Term{t1, t2}) // ~string | []byte P := NewTypeName(nopos, nil, "P", nil) // [P ~string | []byte] makeSig(NewTypeParam(P, NewInterfaceType(nil, []Type{u}))) } } func TestIssue51093(t *testing.T) { // Each test stands for a conversion of the form P(val) // where P is a type parameter with typ as constraint. // The test ensures that P(val) has the correct type P // and is not a constant. var tests = []struct { typ string val string }{ {"bool", "false"}, {"int", "-1"}, {"uint", "1.0"}, {"rune", "'a'"}, {"float64", "3.5"}, {"complex64", "1.25"}, {"string", "\"foo\""}, // some more complex constraints {"~byte", "1"}, {"~int | ~float64 | complex128", "1"}, {"~uint64 | ~rune", "'X'"}, } for _, test := range tests { src := fmt.Sprintf("package p; func _[P %s]() { _ = P(%s) }", test.typ, test.val) types := make(map[syntax.Expr]TypeAndValue) mustTypecheck(src, nil, &Info{Types: types}) var n int for x, tv := range types { if x, _ := x.(*syntax.CallExpr); x != nil { // there must be exactly one CallExpr which is the P(val) conversion n++ tpar, _ := tv.Type.(*TypeParam) if tpar == nil { t.Fatalf("%s: got type %s, want type parameter", syntax.String(x), tv.Type) } if name := tpar.Obj().Name(); name != "P" { t.Fatalf("%s: got type parameter name %s, want P", syntax.String(x), name) } // P(val) must not be constant if tv.Value != nil { t.Errorf("%s: got constant value %s (%s), want no constant", syntax.String(x), tv.Value, tv.Value.String()) } } } if n != 1 { t.Fatalf("%s: got %d CallExpr nodes; want 1", src, 1) } } } func TestIssue54258(t *testing.T) { tests := []struct{ main, b, want string }{ { //--------------------------------------------------------------- `package main import "b" type I0 interface { M0(w struct{ f string }) } var _ I0 = b.S{} `, `package b type S struct{} func (S) M0(struct{ f string }) {} `, `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I0 value in variable declaration: b[.]S does not implement I0 [(]wrong type for method M0[)] .*have M0[(]struct{f string /[*] package b [*]/ }[)] .*want M0[(]struct{f string /[*] package main [*]/ }[)]`}, { //--------------------------------------------------------------- `package main import "b" type I1 interface { M1(struct{ string }) } var _ I1 = b.S{} `, `package b type S struct{} func (S) M1(struct{ string }) {} `, `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I1 value in variable declaration: b[.]S does not implement I1 [(]wrong type for method M1[)] .*have M1[(]struct{string /[*] package b [*]/ }[)] .*want M1[(]struct{string /[*] package main [*]/ }[)]`}, { //--------------------------------------------------------------- `package main import "b" type I2 interface { M2(y struct{ f struct{ f string } }) } var _ I2 = b.S{} `, `package b type S struct{} func (S) M2(struct{ f struct{ f string } }) {} `, `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I2 value in variable declaration: b[.]S does not implement I2 [(]wrong type for method M2[)] .*have M2[(]struct{f struct{f string} /[*] package b [*]/ }[)] .*want M2[(]struct{f struct{f string} /[*] package main [*]/ }[)]`}, { //--------------------------------------------------------------- `package main import "b" type I3 interface { M3(z struct{ F struct{ f string } }) } var _ I3 = b.S{} `, `package b type S struct{} func (S) M3(struct{ F struct{ f string } }) {} `, `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I3 value in variable declaration: b[.]S does not implement I3 [(]wrong type for method M3[)] .*have M3[(]struct{F struct{f string /[*] package b [*]/ }}[)] .*want M3[(]struct{F struct{f string /[*] package main [*]/ }}[)]`}, { //--------------------------------------------------------------- `package main import "b" type I4 interface { M4(_ struct { *string }) } var _ I4 = b.S{} `, `package b type S struct{} func (S) M4(struct { *string }) {} `, `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I4 value in variable declaration: b[.]S does not implement I4 [(]wrong type for method M4[)] .*have M4[(]struct{[*]string /[*] package b [*]/ }[)] .*want M4[(]struct{[*]string /[*] package main [*]/ }[)]`}, { //--------------------------------------------------------------- `package main import "b" type t struct{ A int } type I5 interface { M5(_ struct {b.S;t}) } var _ I5 = b.S{} `, `package b type S struct{} type t struct{ A int } func (S) M5(struct {S;t}) {} `, `7:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I5 value in variable declaration: b[.]S does not implement I5 [(]wrong type for method M5[)] .*have M5[(]struct{b[.]S; b[.]t}[)] .*want M5[(]struct{b[.]S; t}[)]`}, } test := func(main, b, want string) { re := regexp.MustCompile(want) bpkg := mustTypecheck(b, nil, nil) mast := mustParse(main) conf := Config{Importer: importHelper{pkg: bpkg}} _, err := conf.Check(mast.PkgName.Value, []*syntax.File{mast}, nil) if err == nil { t.Error("Expected failure, but it did not") } else if got := err.Error(); !re.MatchString(got) { t.Errorf("Wanted match for\n\t%s\n but got\n\t%s", want, got) } else if testing.Verbose() { t.Logf("Saw expected\n\t%s", err.Error()) } } for _, t := range tests { test(t.main, t.b, t.want) } } func TestIssue59944(t *testing.T) { testenv.MustHaveCGO(t) // The typechecker should resolve methods declared on aliases of cgo types. const src = ` package p /* struct layout { int field; }; */ import "C" type Layout = C.struct_layout func (l *Layout) Binding() {} func _() { _ = (*Layout).Binding } ` // code generated by cmd/cgo for the above source. const cgoTypes = ` // Code generated by cmd/cgo; DO NOT EDIT. package p import "unsafe" import "syscall" import _cgopackage "runtime/cgo" type _ _cgopackage.Incomplete var _ syscall.Errno func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr } //go:linkname _Cgo_always_false runtime.cgoAlwaysFalse var _Cgo_always_false bool //go:linkname _Cgo_use runtime.cgoUse func _Cgo_use(interface{}) type _Ctype_int int32 type _Ctype_struct_layout struct { field _Ctype_int } type _Ctype_void [0]byte //go:linkname _cgo_runtime_cgocall runtime.cgocall func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32 //go:linkname _cgoCheckPointer runtime.cgoCheckPointer func _cgoCheckPointer(interface{}, interface{}) //go:linkname _cgoCheckResult runtime.cgoCheckResult func _cgoCheckResult(interface{}) ` testFiles(t, []string{"p.go", "_cgo_gotypes.go"}, [][]byte{[]byte(src), []byte(cgoTypes)}, 0, false, func(cfg *Config) { *boolFieldAddr(cfg, "go115UsesCgo") = true }) } func TestIssue61931(t *testing.T) { const src = ` package p func A(func(any), ...any) {} func B[T any](T) {} func _() { A(B, nil // syntax error: missing ',' before newline in argument list } ` f, err := syntax.Parse(syntax.NewFileBase(pkgName(src)), strings.NewReader(src), func(error) {}, nil, 0) if err == nil { t.Fatal("expected syntax error") } var conf Config conf.Check(f.PkgName.Value, []*syntax.File{f}, nil) // must not panic } func TestIssue61938(t *testing.T) { const src = ` package p func f[T any]() {} func _() { f() } ` // no error handler provided (this issue) var conf Config typecheck(src, &conf, nil) // must not panic // with error handler (sanity check) conf.Error = func(error) {} typecheck(src, &conf, nil) // must not panic } func TestIssue63260(t *testing.T) { const src = ` package p func _() { use(f[*string]) } func use(func()) {} func f[I *T, T any]() { var v T _ = v }` info := Info{ Defs: make(map[*syntax.Name]Object), } pkg := mustTypecheck(src, nil, &info) // get type parameter T in signature of f T := pkg.Scope().Lookup("f").Type().(*Signature).TypeParams().At(1) if T.Obj().Name() != "T" { t.Fatalf("got type parameter %s, want T", T) } // get type of variable v in body of f var v Object for name, obj := range info.Defs { if name.Value == "v" { v = obj break } } if v == nil { t.Fatal("variable v not found") } // type of v and T must be pointer-identical if v.Type() != T { t.Fatalf("types of v and T are not pointer-identical: %p != %p", v.Type().(*TypeParam), T) } } func TestIssue44410(t *testing.T) { const src = ` package p type A = []int type S struct{ A } ` t.Setenv("GODEBUG", "gotypesalias=1") pkg := mustTypecheck(src, nil, nil) S := pkg.Scope().Lookup("S") if S == nil { t.Fatal("object S not found") } got := S.String() const want = "type p.S struct{p.A}" if got != want { t.Fatalf("got %q; want %q", got, want) } } func TestIssue59831(t *testing.T) { // Package a exports a type S with an unexported method m; // the tests check the error messages when m is not found. const asrc = `package a; type S struct{}; func (S) m() {}` apkg := mustTypecheck(asrc, nil, nil) // Package b exports a type S with an exported method m; // the tests check the error messages when M is not found. const bsrc = `package b; type S struct{}; func (S) M() {}` bpkg := mustTypecheck(bsrc, nil, nil) tests := []struct { imported *Package src, err string }{ // tests importing a (or nothing) {apkg, `package a1; import "a"; var _ interface { M() } = a.S{}`, "a.S does not implement interface{M()} (missing method M) have m() want M()"}, {apkg, `package a2; import "a"; var _ interface { m() } = a.S{}`, "a.S does not implement interface{m()} (unexported method m)"}, // test for issue {nil, `package a3; type S struct{}; func (S) m(); var _ interface { M() } = S{}`, "S does not implement interface{M()} (missing method M) have m() want M()"}, {nil, `package a4; type S struct{}; func (S) m(); var _ interface { m() } = S{}`, ""}, // no error expected {nil, `package a5; type S struct{}; func (S) m(); var _ interface { n() } = S{}`, "S does not implement interface{n()} (missing method n)"}, // tests importing b (or nothing) {bpkg, `package b1; import "b"; var _ interface { m() } = b.S{}`, "b.S does not implement interface{m()} (missing method m) have M() want m()"}, {bpkg, `package b2; import "b"; var _ interface { M() } = b.S{}`, ""}, // no error expected {nil, `package b3; type S struct{}; func (S) M(); var _ interface { M() } = S{}`, ""}, // no error expected {nil, `package b4; type S struct{}; func (S) M(); var _ interface { m() } = S{}`, "S does not implement interface{m()} (missing method m) have M() want m()"}, {nil, `package b5; type S struct{}; func (S) M(); var _ interface { n() } = S{}`, "S does not implement interface{n()} (missing method n)"}, } for _, test := range tests { // typecheck test source conf := Config{Importer: importHelper{pkg: test.imported}} pkg, err := typecheck(test.src, &conf, nil) if err == nil { if test.err != "" { t.Errorf("package %s: got no error, want %q", pkg.Name(), test.err) } continue } if test.err == "" { t.Errorf("package %s: got %q, want not error", pkg.Name(), err.Error()) } // flatten reported error message errmsg := strings.ReplaceAll(err.Error(), "\n", " ") errmsg = strings.ReplaceAll(errmsg, "\t", "") // verify error message if !strings.Contains(errmsg, test.err) { t.Errorf("package %s: got %q, want %q", pkg.Name(), errmsg, test.err) } } } func TestIssue64759(t *testing.T) { const src = ` //go:build go1.18 package p func f[S ~[]E, E any](S) {} func _() { f([]string{}) } ` // Per the go:build directive, the source must typecheck // even though the (module) Go version is set to go1.17. conf := Config{GoVersion: "go1.17"} mustTypecheck(src, &conf, nil) } PK ! �(� sizeof_test.gonu �[��� // Copyright 2021 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 types2 import ( "reflect" "testing" ) // Signal size changes of important structures. func TestSizeof(t *testing.T) { const _64bit = ^uint(0)>>32 != 0 var tests = []struct { val interface{} // type as a value _32bit uintptr // size on 32bit platforms _64bit uintptr // size on 64bit platforms }{ // Types {Basic{}, 16, 32}, {Array{}, 16, 24}, {Slice{}, 8, 16}, {Struct{}, 24, 48}, {Pointer{}, 8, 16}, {Tuple{}, 12, 24}, {Signature{}, 28, 56}, {Union{}, 12, 24}, {Interface{}, 40, 80}, {Map{}, 16, 32}, {Chan{}, 12, 24}, {Named{}, 60, 112}, {TypeParam{}, 28, 48}, {term{}, 12, 24}, // Objects {PkgName{}, 64, 104}, {Const{}, 64, 104}, {TypeName{}, 56, 88}, {Var{}, 64, 104}, {Func{}, 64, 104}, {Label{}, 60, 96}, {Builtin{}, 60, 96}, {Nil{}, 56, 88}, // Misc {Scope{}, 60, 104}, {Package{}, 44, 88}, {_TypeSet{}, 28, 56}, } for _, test := range tests { got := reflect.TypeOf(test.val).Size() want := test._32bit if _64bit { want = test._64bit } if got != want { t.Errorf("unsafe.Sizeof(%T) = %d, want %d", test.val, got, want) } } } PK ! �˹�� � basic.gonu �[��� // Copyright 2011 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 types2 // BasicKind describes the kind of basic type. type BasicKind int const ( Invalid BasicKind = iota // type is invalid // predeclared types Bool Int Int8 Int16 Int32 Int64 Uint Uint8 Uint16 Uint32 Uint64 Uintptr Float32 Float64 Complex64 Complex128 String UnsafePointer // types for untyped values UntypedBool UntypedInt UntypedRune UntypedFloat UntypedComplex UntypedString UntypedNil // aliases Byte = Uint8 Rune = Int32 ) // BasicInfo is a set of flags describing properties of a basic type. type BasicInfo int // Properties of basic types. const ( IsBoolean BasicInfo = 1 << iota IsInteger IsUnsigned IsFloat IsComplex IsString IsUntyped IsOrdered = IsInteger | IsFloat | IsString IsNumeric = IsInteger | IsFloat | IsComplex IsConstType = IsBoolean | IsNumeric | IsString ) // A Basic represents a basic type. type Basic struct { kind BasicKind info BasicInfo name string } // Kind returns the kind of basic type b. func (b *Basic) Kind() BasicKind { return b.kind } // Info returns information about properties of basic type b. func (b *Basic) Info() BasicInfo { return b.info } // Name returns the name of basic type b. func (b *Basic) Name() string { return b.name } func (b *Basic) Underlying() Type { return b } func (b *Basic) String() string { return TypeString(b, nil) } PK ! ����S S typeterm_test.gonu �[��� // Copyright 2021 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 types2 import ( "strings" "testing" ) var myInt = func() Type { tname := NewTypeName(nopos, nil, "myInt", nil) return NewNamed(tname, Typ[Int], nil) }() var testTerms = map[string]*term{ "∅": nil, "𝓤": {}, "int": {false, Typ[Int]}, "~int": {true, Typ[Int]}, "string": {false, Typ[String]}, "~string": {true, Typ[String]}, "myInt": {false, myInt}, } func TestTermString(t *testing.T) { for want, x := range testTerms { if got := x.String(); got != want { t.Errorf("%v.String() == %v; want %v", x, got, want) } } } func split(s string, n int) []string { r := strings.Split(s, " ") if len(r) != n { panic("invalid test case: " + s) } return r } func testTerm(name string) *term { r, ok := testTerms[name] if !ok { panic("invalid test argument: " + name) } return r } func TestTermEqual(t *testing.T) { for _, test := range []string{ "∅ ∅ T", "𝓤 𝓤 T", "int int T", "~int ~int T", "myInt myInt T", "∅ 𝓤 F", "∅ int F", "∅ ~int F", "𝓤 int F", "𝓤 ~int F", "𝓤 myInt F", "int ~int F", "int myInt F", "~int myInt F", } { args := split(test, 3) x := testTerm(args[0]) y := testTerm(args[1]) want := args[2] == "T" if got := x.equal(y); got != want { t.Errorf("%v.equal(%v) = %v; want %v", x, y, got, want) } // equal is symmetric x, y = y, x if got := x.equal(y); got != want { t.Errorf("%v.equal(%v) = %v; want %v", x, y, got, want) } } } func TestTermUnion(t *testing.T) { for _, test := range []string{ "∅ ∅ ∅ ∅", "∅ 𝓤 𝓤 ∅", "∅ int int ∅", "∅ ~int ~int ∅", "∅ myInt myInt ∅", "𝓤 𝓤 𝓤 ∅", "𝓤 int 𝓤 ∅", "𝓤 ~int 𝓤 ∅", "𝓤 myInt 𝓤 ∅", "int int int ∅", "int ~int ~int ∅", "int string int string", "int ~string int ~string", "int myInt int myInt", "~int ~string ~int ~string", "~int myInt ~int ∅", // union is symmetric, but the result order isn't - repeat symmetric cases explicitly "𝓤 ∅ 𝓤 ∅", "int ∅ int ∅", "~int ∅ ~int ∅", "myInt ∅ myInt ∅", "int 𝓤 𝓤 ∅", "~int 𝓤 𝓤 ∅", "myInt 𝓤 𝓤 ∅", "~int int ~int ∅", "string int string int", "~string int ~string int", "myInt int myInt int", "~string ~int ~string ~int", "myInt ~int ~int ∅", } { args := split(test, 4) x := testTerm(args[0]) y := testTerm(args[1]) want1 := testTerm(args[2]) want2 := testTerm(args[3]) if got1, got2 := x.union(y); !got1.equal(want1) || !got2.equal(want2) { t.Errorf("%v.union(%v) = %v, %v; want %v, %v", x, y, got1, got2, want1, want2) } } } func TestTermIntersection(t *testing.T) { for _, test := range []string{ "∅ ∅ ∅", "∅ 𝓤 ∅", "∅ int ∅", "∅ ~int ∅", "∅ myInt ∅", "𝓤 𝓤 𝓤", "𝓤 int int", "𝓤 ~int ~int", "𝓤 myInt myInt", "int int int", "int ~int int", "int string ∅", "int ~string ∅", "int string ∅", "~int ~string ∅", "~int myInt myInt", } { args := split(test, 3) x := testTerm(args[0]) y := testTerm(args[1]) want := testTerm(args[2]) if got := x.intersect(y); !got.equal(want) { t.Errorf("%v.intersect(%v) = %v; want %v", x, y, got, want) } // intersect is symmetric x, y = y, x if got := x.intersect(y); !got.equal(want) { t.Errorf("%v.intersect(%v) = %v; want %v", x, y, got, want) } } } func TestTermIncludes(t *testing.T) { for _, test := range []string{ "∅ int F", "𝓤 int T", "int int T", "~int int T", "~int myInt T", "string int F", "~string int F", "myInt int F", } { args := split(test, 3) x := testTerm(args[0]) y := testTerm(args[1]).typ want := args[2] == "T" if got := x.includes(y); got != want { t.Errorf("%v.includes(%v) = %v; want %v", x, y, got, want) } } } func TestTermSubsetOf(t *testing.T) { for _, test := range []string{ "∅ ∅ T", "𝓤 𝓤 T", "int int T", "~int ~int T", "myInt myInt T", "∅ 𝓤 T", "∅ int T", "∅ ~int T", "∅ myInt T", "𝓤 int F", "𝓤 ~int F", "𝓤 myInt F", "int ~int T", "int myInt F", "~int myInt F", "myInt int F", "myInt ~int T", } { args := split(test, 3) x := testTerm(args[0]) y := testTerm(args[1]) want := args[2] == "T" if got := x.subsetOf(y); got != want { t.Errorf("%v.subsetOf(%v) = %v; want %v", x, y, got, want) } } } func TestTermDisjoint(t *testing.T) { for _, test := range []string{ "int int F", "~int ~int F", "int ~int F", "int string T", "int ~string T", "int myInt T", "~int ~string T", "~int myInt F", "string myInt T", "~string myInt T", } { args := split(test, 3) x := testTerm(args[0]) y := testTerm(args[1]) want := args[2] == "T" if got := x.disjoint(y); got != want { t.Errorf("%v.disjoint(%v) = %v; want %v", x, y, got, want) } // disjoint is symmetric x, y = y, x if got := x.disjoint(y); got != want { t.Errorf("%v.disjoint(%v) = %v; want %v", x, y, got, want) } } } PK ! ��7� util_test.gonu �[��� // Copyright 2023 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. // This file exports various functionality of util.go // so that it can be used in (package-external) tests. package types2 import ( "cmd/compile/internal/syntax" ) func CmpPos(p, q syntax.Pos) int { return cmpPos(p, q) } func ScopeComment(s *Scope) string { return s.comment } func ObjectScopePos(obj Object) syntax.Pos { return obj.scopePos() } PK ! q�ʛ� � struct.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" "strconv" ) // ---------------------------------------------------------------------------- // API // A Struct represents a struct type. type Struct struct { fields []*Var // fields != nil indicates the struct is set up (possibly with len(fields) == 0) tags []string // field tags; nil if there are no tags } // NewStruct returns a new struct with the given fields and corresponding field tags. // If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be // only as long as required to hold the tag with the largest index i. Consequently, // if no field has a tag, tags may be nil. func NewStruct(fields []*Var, tags []string) *Struct { var fset objset for _, f := range fields { if f.name != "_" && fset.insert(f) != nil { panic("multiple fields with the same name") } } if len(tags) > len(fields) { panic("more tags than fields") } s := &Struct{fields: fields, tags: tags} s.markComplete() return s } // NumFields returns the number of fields in the struct (including blank and embedded fields). func (s *Struct) NumFields() int { return len(s.fields) } // Field returns the i'th field for 0 <= i < NumFields(). func (s *Struct) Field(i int) *Var { return s.fields[i] } // Tag returns the i'th field tag for 0 <= i < NumFields(). func (s *Struct) Tag(i int) string { if i < len(s.tags) { return s.tags[i] } return "" } func (s *Struct) Underlying() Type { return s } func (s *Struct) String() string { return TypeString(s, nil) } // ---------------------------------------------------------------------------- // Implementation func (s *Struct) markComplete() { if s.fields == nil { s.fields = make([]*Var, 0) } } func (check *Checker) structType(styp *Struct, e *syntax.StructType) { if e.FieldList == nil { styp.markComplete() return } // struct fields and tags var fields []*Var var tags []string // for double-declaration checks var fset objset // current field typ and tag var typ Type var tag string add := func(ident *syntax.Name, embedded bool, pos syntax.Pos) { if tag != "" && tags == nil { tags = make([]string, len(fields)) } if tags != nil { tags = append(tags, tag) } name := ident.Value fld := NewField(pos, check.pkg, name, typ, embedded) // spec: "Within a struct, non-blank field names must be unique." if name == "_" || check.declareInSet(&fset, pos, fld) { fields = append(fields, fld) check.recordDef(ident, fld) } } // addInvalid adds an embedded field of invalid type to the struct for // fields with errors; this keeps the number of struct fields in sync // with the source as long as the fields are _ or have different names // (go.dev/issue/25627). addInvalid := func(ident *syntax.Name, pos syntax.Pos) { typ = Typ[Invalid] tag = "" add(ident, true, pos) } var prev syntax.Expr for i, f := range e.FieldList { // Fields declared syntactically with the same type (e.g.: a, b, c T) // share the same type expression. Only check type if it's a new type. if i == 0 || f.Type != prev { typ = check.varType(f.Type) prev = f.Type } tag = "" if i < len(e.TagList) { tag = check.tag(e.TagList[i]) } if f.Name != nil { // named field add(f.Name, false, f.Name.Pos()) } else { // embedded field // spec: "An embedded type must be specified as a type name T or as a // pointer to a non-interface type name *T, and T itself may not be a // pointer type." pos := syntax.StartPos(f.Type) // position of type, for errors name := embeddedFieldIdent(f.Type) if name == nil { check.errorf(pos, InvalidSyntaxTree, "invalid embedded field type %s", f.Type) name = &syntax.Name{Value: "_"} // TODO(gri) need to set position to pos addInvalid(name, pos) continue } add(name, true, name.Pos()) // struct{p.T} field has position of T // Because we have a name, typ must be of the form T or *T, where T is the name // of a (named or alias) type, and t (= deref(typ)) must be the type of T. // We must delay this check to the end because we don't want to instantiate // (via under(t)) a possibly incomplete type. embeddedTyp := typ // for closure below embeddedPos := pos check.later(func() { t, isPtr := deref(embeddedTyp) switch u := under(t).(type) { case *Basic: if !isValid(t) { // error was reported before return } // unsafe.Pointer is treated like a regular pointer if u.kind == UnsafePointer { check.error(embeddedPos, InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer") } case *Pointer: check.error(embeddedPos, InvalidPtrEmbed, "embedded field type cannot be a pointer") case *Interface: if isTypeParam(t) { // The error code here is inconsistent with other error codes for // invalid embedding, because this restriction may be relaxed in the // future, and so it did not warrant a new error code. check.error(embeddedPos, MisplacedTypeParam, "embedded field type cannot be a (pointer to a) type parameter") break } if isPtr { check.error(embeddedPos, InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface") } } }).describef(embeddedPos, "check embedded type %s", embeddedTyp) } } styp.fields = fields styp.tags = tags styp.markComplete() } func embeddedFieldIdent(e syntax.Expr) *syntax.Name { switch e := e.(type) { case *syntax.Name: return e case *syntax.Operation: if base := ptrBase(e); base != nil { // *T is valid, but **T is not if op, _ := base.(*syntax.Operation); op == nil || ptrBase(op) == nil { return embeddedFieldIdent(e.X) } } case *syntax.SelectorExpr: return e.Sel case *syntax.IndexExpr: return embeddedFieldIdent(e.X) } return nil // invalid embedded field } func (check *Checker) declareInSet(oset *objset, pos syntax.Pos, obj Object) bool { if alt := oset.insert(obj); alt != nil { var err error_ err.code = DuplicateDecl err.errorf(pos, "%s redeclared", obj.Name()) err.recordAltDecl(alt) check.report(&err) return false } return true } func (check *Checker) tag(t *syntax.BasicLit) string { // If t.Bad, an error was reported during parsing. if t != nil && !t.Bad { if t.Kind == syntax.StringLit { if val, err := strconv.Unquote(t.Value); err == nil { return val } } check.errorf(t, InvalidSyntaxTree, "incorrect tag syntax: %q", t.Value) } return "" } func ptrBase(x *syntax.Operation) syntax.Expr { if x.Op == syntax.Mul && x.Y == nil { return x.X } return nil } PK ! (d��m m hilbert_test.gonu �[��� // Copyright 2013 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 types2_test import ( "bytes" "flag" "fmt" "os" "testing" . "cmd/compile/internal/types2" ) var ( H = flag.Int("H", 5, "Hilbert matrix size") out = flag.String("out", "", "write generated program to out") ) func TestHilbert(t *testing.T) { // generate source src := program(*H, *out) if *out != "" { os.WriteFile(*out, src, 0666) return } DefPredeclaredTestFuncs() // declare assert (used by code generated by verify) mustTypecheck(string(src), nil, nil) } func program(n int, out string) []byte { var g gen g.p(`// Code generated by: go test -run=Hilbert -H=%d -out=%q. DO NOT EDIT. // +`+`build ignore // This program tests arbitrary precision constant arithmetic // by generating the constant elements of a Hilbert matrix H, // its inverse I, and the product P = H*I. The product should // be the identity matrix. package main func main() { if !ok { printProduct() return } println("PASS") } `, n, out) g.hilbert(n) g.inverse(n) g.product(n) g.verify(n) g.printProduct(n) g.binomials(2*n - 1) g.factorials(2*n - 1) return g.Bytes() } type gen struct { bytes.Buffer } func (g *gen) p(format string, args ...interface{}) { fmt.Fprintf(&g.Buffer, format, args...) } func (g *gen) hilbert(n int) { g.p(`// Hilbert matrix, n = %d const ( `, n) for i := 0; i < n; i++ { g.p("\t") for j := 0; j < n; j++ { if j > 0 { g.p(", ") } g.p("h%d_%d", i, j) } if i == 0 { g.p(" = ") for j := 0; j < n; j++ { if j > 0 { g.p(", ") } g.p("1.0/(iota + %d)", j+1) } } g.p("\n") } g.p(")\n\n") } func (g *gen) inverse(n int) { g.p(`// Inverse Hilbert matrix const ( `) for i := 0; i < n; i++ { for j := 0; j < n; j++ { s := "+" if (i+j)&1 != 0 { s = "-" } g.p("\ti%d_%d = %s%d * b%d_%d * b%d_%d * b%d_%d * b%d_%d\n", i, j, s, i+j+1, n+i, n-j-1, n+j, n-i-1, i+j, i, i+j, i) } g.p("\n") } g.p(")\n\n") } func (g *gen) product(n int) { g.p(`// Product matrix const ( `) for i := 0; i < n; i++ { for j := 0; j < n; j++ { g.p("\tp%d_%d = ", i, j) for k := 0; k < n; k++ { if k > 0 { g.p(" + ") } g.p("h%d_%d*i%d_%d", i, k, k, j) } g.p("\n") } g.p("\n") } g.p(")\n\n") } func (g *gen) verify(n int) { g.p(`// Verify that product is the identity matrix const ok = `) for i := 0; i < n; i++ { for j := 0; j < n; j++ { if j == 0 { g.p("\t") } else { g.p(" && ") } v := 0 if i == j { v = 1 } g.p("p%d_%d == %d", i, j, v) } g.p(" &&\n") } g.p("\ttrue\n\n") // verify ok at type-check time if *out == "" { g.p("const _ = assert(ok)\n\n") } } func (g *gen) printProduct(n int) { g.p("func printProduct() {\n") for i := 0; i < n; i++ { g.p("\tprintln(") for j := 0; j < n; j++ { if j > 0 { g.p(", ") } g.p("p%d_%d", i, j) } g.p(")\n") } g.p("}\n\n") } func (g *gen) binomials(n int) { g.p(`// Binomials const ( `) for j := 0; j <= n; j++ { if j > 0 { g.p("\n") } for k := 0; k <= j; k++ { g.p("\tb%d_%d = f%d / (f%d*f%d)\n", j, k, j, k, j-k) } } g.p(")\n\n") } func (g *gen) factorials(n int) { g.p(`// Factorials const ( f0 = 1 f1 = 1 `) for i := 2; i <= n; i++ { g.p("\tf%d = f%d * %d\n", i, i-1, i) } g.p(")\n\n") } PK ! ��& named_test.gonu �[��� // Copyright 2022 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 types2_test import ( "testing" "cmd/compile/internal/syntax" . "cmd/compile/internal/types2" ) func BenchmarkNamed(b *testing.B) { const src = ` package p type T struct { P int } func (T) M(int) {} func (T) N() (i int) { return } type G[P any] struct { F P } func (G[P]) M(P) {} func (G[P]) N() (p P) { return } type Inst = G[int] ` pkg := mustTypecheck(src, nil, nil) var ( T = pkg.Scope().Lookup("T").Type() G = pkg.Scope().Lookup("G").Type() SrcInst = pkg.Scope().Lookup("Inst").Type() UserInst = mustInstantiate(b, G, Typ[Int]) ) tests := []struct { name string typ Type }{ {"nongeneric", T}, {"generic", G}, {"src instance", SrcInst}, {"user instance", UserInst}, } b.Run("Underlying", func(b *testing.B) { for _, test := range tests { b.Run(test.name, func(b *testing.B) { // Access underlying once, to trigger any lazy calculation. _ = test.typ.Underlying() b.ResetTimer() for i := 0; i < b.N; i++ { _ = test.typ.Underlying() } }) } }) } func mustInstantiate(tb testing.TB, orig Type, targs ...Type) Type { inst, err := Instantiate(nil, orig, targs, true) if err != nil { tb.Fatal(err) } return inst } // Test that types do not expand infinitely, as in go.dev/issue/52715. func TestFiniteTypeExpansion(t *testing.T) { const src = ` package p type Tree[T any] struct { *Node[T] } func (*Tree[R]) N(r R) R { return r } type Node[T any] struct { *Tree[T] } func (Node[Q]) M(Q) {} type Inst = *Tree[int] ` f := mustParse(src) pkg := NewPackage("p", f.PkgName.Value) if err := NewChecker(nil, pkg, nil).Files([]*syntax.File{f}); err != nil { t.Fatal(err) } firstFieldType := func(n *Named) *Named { return n.Underlying().(*Struct).Field(0).Type().(*Pointer).Elem().(*Named) } Inst := pkg.Scope().Lookup("Inst").Type().(*Pointer).Elem().(*Named) Node := firstFieldType(Inst) Tree := firstFieldType(Node) if !Identical(Inst, Tree) { t.Fatalf("Not a cycle: got %v, want %v", Tree, Inst) } if Inst != Tree { t.Errorf("Duplicate instances in cycle: %s (%p) -> %s (%p) -> %s (%p)", Inst, Inst, Node, Node, Tree, Tree) } } PK ! J��~{ { pointer.gonu �[��� // Copyright 2011 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 types2 // A Pointer represents a pointer type. type Pointer struct { base Type // element type } // NewPointer returns a new pointer type for the given element (base) type. func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} } // Elem returns the element type for the given pointer p. func (p *Pointer) Elem() Type { return p.base } func (p *Pointer) Underlying() Type { return p } func (p *Pointer) String() string { return TypeString(p, nil) } PK ! ٌ��� � universe.gonu �[��� // Copyright 2011 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. // This file sets up the universe scope and the unsafe package. package types2 import ( "go/constant" "strings" ) // The Universe scope contains all predeclared objects of Go. // It is the outermost scope of any chain of nested scopes. var Universe *Scope // The Unsafe package is the package returned by an importer // for the import path "unsafe". var Unsafe *Package var ( universeIota Object universeByte Type // uint8 alias, but has name "byte" universeRune Type // int32 alias, but has name "rune" universeAny Object universeError Type universeComparable Object ) // Typ contains the predeclared *Basic types indexed by their // corresponding BasicKind. // // The *Basic type for Typ[Byte] will have the name "uint8". // Use Universe.Lookup("byte").Type() to obtain the specific // alias basic type named "byte" (and analogous for "rune"). var Typ = [...]*Basic{ Invalid: {Invalid, 0, "invalid type"}, Bool: {Bool, IsBoolean, "bool"}, Int: {Int, IsInteger, "int"}, Int8: {Int8, IsInteger, "int8"}, Int16: {Int16, IsInteger, "int16"}, Int32: {Int32, IsInteger, "int32"}, Int64: {Int64, IsInteger, "int64"}, Uint: {Uint, IsInteger | IsUnsigned, "uint"}, Uint8: {Uint8, IsInteger | IsUnsigned, "uint8"}, Uint16: {Uint16, IsInteger | IsUnsigned, "uint16"}, Uint32: {Uint32, IsInteger | IsUnsigned, "uint32"}, Uint64: {Uint64, IsInteger | IsUnsigned, "uint64"}, Uintptr: {Uintptr, IsInteger | IsUnsigned, "uintptr"}, Float32: {Float32, IsFloat, "float32"}, Float64: {Float64, IsFloat, "float64"}, Complex64: {Complex64, IsComplex, "complex64"}, Complex128: {Complex128, IsComplex, "complex128"}, String: {String, IsString, "string"}, UnsafePointer: {UnsafePointer, 0, "Pointer"}, UntypedBool: {UntypedBool, IsBoolean | IsUntyped, "untyped bool"}, UntypedInt: {UntypedInt, IsInteger | IsUntyped, "untyped int"}, UntypedRune: {UntypedRune, IsInteger | IsUntyped, "untyped rune"}, UntypedFloat: {UntypedFloat, IsFloat | IsUntyped, "untyped float"}, UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"}, UntypedString: {UntypedString, IsString | IsUntyped, "untyped string"}, UntypedNil: {UntypedNil, IsUntyped, "untyped nil"}, } var aliases = [...]*Basic{ {Byte, IsInteger | IsUnsigned, "byte"}, {Rune, IsInteger, "rune"}, } func defPredeclaredTypes() { for _, t := range Typ { def(NewTypeName(nopos, nil, t.name, t)) } for _, t := range aliases { def(NewTypeName(nopos, nil, t.name, t)) } // type any = interface{} // Note: don't use &emptyInterface for the type of any. Using a unique // pointer allows us to detect any and format it as "any" rather than // interface{}, which clarifies user-facing error messages significantly. def(NewTypeName(nopos, nil, "any", &Interface{complete: true, tset: &topTypeSet})) // type error interface{ Error() string } { obj := NewTypeName(nopos, nil, "error", nil) obj.setColor(black) typ := NewNamed(obj, nil, nil) // error.Error() string recv := NewVar(nopos, nil, "", typ) res := NewVar(nopos, nil, "", Typ[String]) sig := NewSignatureType(recv, nil, nil, nil, NewTuple(res), false) err := NewFunc(nopos, nil, "Error", sig) // interface{ Error() string } ityp := &Interface{methods: []*Func{err}, complete: true} computeInterfaceTypeSet(nil, nopos, ityp) // prevent races due to lazy computation of tset typ.SetUnderlying(ityp) def(obj) } // type comparable interface{} // marked as comparable { obj := NewTypeName(nopos, nil, "comparable", nil) obj.setColor(black) typ := NewNamed(obj, nil, nil) // interface{} // marked as comparable ityp := &Interface{complete: true, tset: &_TypeSet{nil, allTermlist, true}} typ.SetUnderlying(ityp) def(obj) } } var predeclaredConsts = [...]struct { name string kind BasicKind val constant.Value }{ {"true", UntypedBool, constant.MakeBool(true)}, {"false", UntypedBool, constant.MakeBool(false)}, {"iota", UntypedInt, constant.MakeInt64(0)}, } func defPredeclaredConsts() { for _, c := range predeclaredConsts { def(NewConst(nopos, nil, c.name, Typ[c.kind], c.val)) } } func defPredeclaredNil() { def(&Nil{object{name: "nil", typ: Typ[UntypedNil], color_: black}}) } // A builtinId is the id of a builtin function. type builtinId int const ( // universe scope _Append builtinId = iota _Cap _Clear _Close _Complex _Copy _Delete _Imag _Len _Make _Max _Min _New _Panic _Print _Println _Real _Recover // package unsafe _Add _Alignof _Offsetof _Sizeof _Slice _SliceData _String _StringData // testing support _Assert _Trace ) var predeclaredFuncs = [...]struct { name string nargs int variadic bool kind exprKind }{ _Append: {"append", 1, true, expression}, _Cap: {"cap", 1, false, expression}, _Clear: {"clear", 1, false, statement}, _Close: {"close", 1, false, statement}, _Complex: {"complex", 2, false, expression}, _Copy: {"copy", 2, false, statement}, _Delete: {"delete", 2, false, statement}, _Imag: {"imag", 1, false, expression}, _Len: {"len", 1, false, expression}, _Make: {"make", 1, true, expression}, // To disable max/min, remove the next two lines. _Max: {"max", 1, true, expression}, _Min: {"min", 1, true, expression}, _New: {"new", 1, false, expression}, _Panic: {"panic", 1, false, statement}, _Print: {"print", 0, true, statement}, _Println: {"println", 0, true, statement}, _Real: {"real", 1, false, expression}, _Recover: {"recover", 0, false, statement}, _Add: {"Add", 2, false, expression}, _Alignof: {"Alignof", 1, false, expression}, _Offsetof: {"Offsetof", 1, false, expression}, _Sizeof: {"Sizeof", 1, false, expression}, _Slice: {"Slice", 2, false, expression}, _SliceData: {"SliceData", 1, false, expression}, _String: {"String", 2, false, expression}, _StringData: {"StringData", 1, false, expression}, _Assert: {"assert", 1, false, statement}, _Trace: {"trace", 0, true, statement}, } func defPredeclaredFuncs() { for i := range predeclaredFuncs { id := builtinId(i) if id == _Assert || id == _Trace { continue // only define these in testing environment } def(newBuiltin(id)) } } // DefPredeclaredTestFuncs defines the assert and trace built-ins. // These built-ins are intended for debugging and testing of this // package only. func DefPredeclaredTestFuncs() { if Universe.Lookup("assert") != nil { return // already defined } def(newBuiltin(_Assert)) def(newBuiltin(_Trace)) } func init() { Universe = NewScope(nil, nopos, nopos, "universe") Unsafe = NewPackage("unsafe", "unsafe") Unsafe.complete = true defPredeclaredTypes() defPredeclaredConsts() defPredeclaredNil() defPredeclaredFuncs() universeIota = Universe.Lookup("iota") universeByte = Universe.Lookup("byte").Type() universeRune = Universe.Lookup("rune").Type() universeAny = Universe.Lookup("any") universeError = Universe.Lookup("error").Type() universeComparable = Universe.Lookup("comparable") } // Objects with names containing blanks are internal and not entered into // a scope. Objects with exported names are inserted in the unsafe package // scope; other objects are inserted in the universe scope. func def(obj Object) { assert(obj.color() == black) name := obj.Name() if strings.Contains(name, " ") { return // nothing to do } // fix Obj link for named types if typ := asNamed(obj.Type()); typ != nil { typ.obj = obj.(*TypeName) } // exported identifiers go into package unsafe scope := Universe if obj.Exported() { scope = Unsafe.scope // set Pkg field switch obj := obj.(type) { case *TypeName: obj.pkg = Unsafe case *Builtin: obj.pkg = Unsafe default: unreachable() } } if scope.Insert(obj) != nil { panic("double declaration of predeclared identifier") } } PK ! ��� @ @ assignments.gonu �[��� // Copyright 2013 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. // This file implements initialization and assignment checks. package types2 import ( "cmd/compile/internal/syntax" "fmt" . "internal/types/errors" "strings" ) // assignment reports whether x can be assigned to a variable of type T, // if necessary by attempting to convert untyped values to the appropriate // type. context describes the context in which the assignment takes place. // Use T == nil to indicate assignment to an untyped blank identifier. // If the assignment check fails, x.mode is set to invalid. func (check *Checker) assignment(x *operand, T Type, context string) { check.singleValue(x) switch x.mode { case invalid: return // error reported before case constant_, variable, mapindex, value, nilvalue, commaok, commaerr: // ok default: // we may get here because of other problems (go.dev/issue/39634, crash 12) // TODO(gri) do we need a new "generic" error code here? check.errorf(x, IncompatibleAssign, "cannot assign %s to %s in %s", x, T, context) x.mode = invalid return } if isUntyped(x.typ) { target := T // spec: "If an untyped constant is assigned to a variable of interface // type or the blank identifier, the constant is first converted to type // bool, rune, int, float64, complex128 or string respectively, depending // on whether the value is a boolean, rune, integer, floating-point, // complex, or string constant." if x.isNil() { if T == nil { check.errorf(x, UntypedNilUse, "use of untyped nil in %s", context) x.mode = invalid return } } else if T == nil || isNonTypeParamInterface(T) { target = Default(x.typ) } newType, val, code := check.implicitTypeAndValue(x, target) if code != 0 { msg := check.sprintf("cannot use %s as %s value in %s", x, target, context) switch code { case TruncatedFloat: msg += " (truncated)" case NumericOverflow: msg += " (overflows)" default: code = IncompatibleAssign } check.error(x, code, msg) x.mode = invalid return } if val != nil { x.val = val check.updateExprVal(x.expr, val) } if newType != x.typ { x.typ = newType check.updateExprType(x.expr, newType, false) } } // x.typ is typed // A generic (non-instantiated) function value cannot be assigned to a variable. if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { check.errorf(x, WrongTypeArgCount, "cannot use generic function %s without instantiation in %s", x, context) x.mode = invalid return } // spec: "If a left-hand side is the blank identifier, any typed or // non-constant value except for the predeclared identifier nil may // be assigned to it." if T == nil { return } cause := "" if ok, code := x.assignableTo(check, T, &cause); !ok { if cause != "" { check.errorf(x, code, "cannot use %s as %s value in %s: %s", x, T, context, cause) } else { check.errorf(x, code, "cannot use %s as %s value in %s", x, T, context) } x.mode = invalid } } func (check *Checker) initConst(lhs *Const, x *operand) { if x.mode == invalid || !isValid(x.typ) || !isValid(lhs.typ) { if lhs.typ == nil { lhs.typ = Typ[Invalid] } return } // rhs must be a constant if x.mode != constant_ { check.errorf(x, InvalidConstInit, "%s is not constant", x) if lhs.typ == nil { lhs.typ = Typ[Invalid] } return } assert(isConstType(x.typ)) // If the lhs doesn't have a type yet, use the type of x. if lhs.typ == nil { lhs.typ = x.typ } check.assignment(x, lhs.typ, "constant declaration") if x.mode == invalid { return } lhs.val = x.val } // initVar checks the initialization lhs = x in a variable declaration. // If lhs doesn't have a type yet, it is given the type of x, // or Typ[Invalid] in case of an error. // If the initialization check fails, x.mode is set to invalid. func (check *Checker) initVar(lhs *Var, x *operand, context string) { if x.mode == invalid || !isValid(x.typ) || !isValid(lhs.typ) { if lhs.typ == nil { lhs.typ = Typ[Invalid] } x.mode = invalid return } // If lhs doesn't have a type yet, use the type of x. if lhs.typ == nil { typ := x.typ if isUntyped(typ) { // convert untyped types to default types if typ == Typ[UntypedNil] { check.errorf(x, UntypedNilUse, "use of untyped nil in %s", context) lhs.typ = Typ[Invalid] x.mode = invalid return } typ = Default(typ) } lhs.typ = typ } check.assignment(x, lhs.typ, context) } // lhsVar checks a lhs variable in an assignment and returns its type. // lhsVar takes care of not counting a lhs identifier as a "use" of // that identifier. The result is nil if it is the blank identifier, // and Typ[Invalid] if it is an invalid lhs expression. func (check *Checker) lhsVar(lhs syntax.Expr) Type { // Determine if the lhs is a (possibly parenthesized) identifier. ident, _ := syntax.Unparen(lhs).(*syntax.Name) // Don't evaluate lhs if it is the blank identifier. if ident != nil && ident.Value == "_" { check.recordDef(ident, nil) return nil } // If the lhs is an identifier denoting a variable v, this reference // is not a 'use' of v. Remember current value of v.used and restore // after evaluating the lhs via check.expr. var v *Var var v_used bool if ident != nil { if obj := check.lookup(ident.Value); obj != nil { // It's ok to mark non-local variables, but ignore variables // from other packages to avoid potential race conditions with // dot-imported variables. if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg { v = w v_used = v.used } } } var x operand check.expr(nil, &x, lhs) if v != nil { v.used = v_used // restore v.used } if x.mode == invalid || !isValid(x.typ) { return Typ[Invalid] } // spec: "Each left-hand side operand must be addressable, a map index // expression, or the blank identifier. Operands may be parenthesized." switch x.mode { case invalid: return Typ[Invalid] case variable, mapindex: // ok default: if sel, ok := x.expr.(*syntax.SelectorExpr); ok { var op operand check.expr(nil, &op, sel.X) if op.mode == mapindex { check.errorf(&x, UnaddressableFieldAssign, "cannot assign to struct field %s in map", syntax.String(x.expr)) return Typ[Invalid] } } check.errorf(&x, UnassignableOperand, "cannot assign to %s (neither addressable nor a map index expression)", x.expr) return Typ[Invalid] } return x.typ } // assignVar checks the assignment lhs = rhs (if x == nil), or lhs = x (if x != nil). // If x != nil, it must be the evaluation of rhs (and rhs will be ignored). // If the assignment check fails and x != nil, x.mode is set to invalid. func (check *Checker) assignVar(lhs, rhs syntax.Expr, x *operand, context string) { T := check.lhsVar(lhs) // nil if lhs is _ if !isValid(T) { if x != nil { x.mode = invalid } else { check.use(rhs) } return } if x == nil { var target *target // avoid calling syntax.String if not needed if T != nil { if _, ok := under(T).(*Signature); ok { target = newTarget(T, syntax.String(lhs)) } } x = new(operand) check.expr(target, x, rhs) } if T == nil && context == "assignment" { context = "assignment to _ identifier" } check.assignment(x, T, context) } // operandTypes returns the list of types for the given operands. func operandTypes(list []*operand) (res []Type) { for _, x := range list { res = append(res, x.typ) } return res } // varTypes returns the list of types for the given variables. func varTypes(list []*Var) (res []Type) { for _, x := range list { res = append(res, x.typ) } return res } // typesSummary returns a string of the form "(t1, t2, ...)" where the // ti's are user-friendly string representations for the given types. // If variadic is set and the last type is a slice, its string is of // the form "...E" where E is the slice's element type. func (check *Checker) typesSummary(list []Type, variadic bool) string { var res []string for i, t := range list { var s string switch { case t == nil: fallthrough // should not happen but be cautious case !isValid(t): s = "unknown type" case isUntyped(t): if isNumeric(t) { // Do not imply a specific type requirement: // "have number, want float64" is better than // "have untyped int, want float64" or // "have int, want float64". s = "number" } else { // If we don't have a number, omit the "untyped" qualifier // for compactness. s = strings.Replace(t.(*Basic).name, "untyped ", "", -1) } case variadic && i == len(list)-1: s = check.sprintf("...%s", t.(*Slice).elem) } if s == "" { s = check.sprintf("%s", t) } res = append(res, s) } return "(" + strings.Join(res, ", ") + ")" } func measure(x int, unit string) string { if x != 1 { unit += "s" } return fmt.Sprintf("%d %s", x, unit) } func (check *Checker) assignError(rhs []syntax.Expr, l, r int) { vars := measure(l, "variable") vals := measure(r, "value") rhs0 := rhs[0] if len(rhs) == 1 { if call, _ := syntax.Unparen(rhs0).(*syntax.CallExpr); call != nil { check.errorf(rhs0, WrongAssignCount, "assignment mismatch: %s but %s returns %s", vars, call.Fun, vals) return } } check.errorf(rhs0, WrongAssignCount, "assignment mismatch: %s but %s", vars, vals) } func (check *Checker) returnError(at poser, lhs []*Var, rhs []*operand) { l, r := len(lhs), len(rhs) qualifier := "not enough" if r > l { at = rhs[l] // report at first extra value qualifier = "too many" } else if r > 0 { at = rhs[r-1] // report at last value } var err error_ err.code = WrongResultCount err.errorf(at, "%s return values", qualifier) err.errorf(nopos, "have %s", check.typesSummary(operandTypes(rhs), false)) err.errorf(nopos, "want %s", check.typesSummary(varTypes(lhs), false)) check.report(&err) } // initVars type-checks assignments of initialization expressions orig_rhs // to variables lhs. // If returnStmt is non-nil, initVars type-checks the implicit assignment // of result expressions orig_rhs to function result parameters lhs. func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnStmt syntax.Stmt) { context := "assignment" if returnStmt != nil { context = "return statement" } l, r := len(lhs), len(orig_rhs) // If l == 1 and the rhs is a single call, for a better // error message don't handle it as n:n mapping below. isCall := false if r == 1 { _, isCall = syntax.Unparen(orig_rhs[0]).(*syntax.CallExpr) } // If we have a n:n mapping from lhs variable to rhs expression, // each value can be assigned to its corresponding variable. if l == r && !isCall { var x operand for i, lhs := range lhs { desc := lhs.name if returnStmt != nil && desc == "" { desc = "result variable" } check.expr(newTarget(lhs.typ, desc), &x, orig_rhs[i]) check.initVar(lhs, &x, context) } return } // If we don't have an n:n mapping, the rhs must be a single expression // resulting in 2 or more values; otherwise we have an assignment mismatch. if r != 1 { // Only report a mismatch error if there are no other errors on the rhs. if check.use(orig_rhs...) { if returnStmt != nil { rhs := check.exprList(orig_rhs) check.returnError(returnStmt, lhs, rhs) } else { check.assignError(orig_rhs, l, r) } } // ensure that LHS variables have a type for _, v := range lhs { if v.typ == nil { v.typ = Typ[Invalid] } } return } rhs, commaOk := check.multiExpr(orig_rhs[0], l == 2 && returnStmt == nil) r = len(rhs) if l == r { for i, lhs := range lhs { check.initVar(lhs, rhs[i], context) } // Only record comma-ok expression if both initializations succeeded // (go.dev/issue/59371). if commaOk && rhs[0].mode != invalid && rhs[1].mode != invalid { check.recordCommaOkTypes(orig_rhs[0], rhs) } return } // In all other cases we have an assignment mismatch. // Only report a mismatch error if there are no other errors on the rhs. if rhs[0].mode != invalid { if returnStmt != nil { check.returnError(returnStmt, lhs, rhs) } else { check.assignError(orig_rhs, l, r) } } // ensure that LHS variables have a type for _, v := range lhs { if v.typ == nil { v.typ = Typ[Invalid] } } // orig_rhs[0] was already evaluated } // assignVars type-checks assignments of expressions orig_rhs to variables lhs. func (check *Checker) assignVars(lhs, orig_rhs []syntax.Expr) { l, r := len(lhs), len(orig_rhs) // If l == 1 and the rhs is a single call, for a better // error message don't handle it as n:n mapping below. isCall := false if r == 1 { _, isCall = syntax.Unparen(orig_rhs[0]).(*syntax.CallExpr) } // If we have a n:n mapping from lhs variable to rhs expression, // each value can be assigned to its corresponding variable. if l == r && !isCall { for i, lhs := range lhs { check.assignVar(lhs, orig_rhs[i], nil, "assignment") } return } // If we don't have an n:n mapping, the rhs must be a single expression // resulting in 2 or more values; otherwise we have an assignment mismatch. if r != 1 { // Only report a mismatch error if there are no other errors on the lhs or rhs. okLHS := check.useLHS(lhs...) okRHS := check.use(orig_rhs...) if okLHS && okRHS { check.assignError(orig_rhs, l, r) } return } rhs, commaOk := check.multiExpr(orig_rhs[0], l == 2) r = len(rhs) if l == r { for i, lhs := range lhs { check.assignVar(lhs, nil, rhs[i], "assignment") } // Only record comma-ok expression if both assignments succeeded // (go.dev/issue/59371). if commaOk && rhs[0].mode != invalid && rhs[1].mode != invalid { check.recordCommaOkTypes(orig_rhs[0], rhs) } return } // In all other cases we have an assignment mismatch. // Only report a mismatch error if there are no other errors on the rhs. if rhs[0].mode != invalid { check.assignError(orig_rhs, l, r) } check.useLHS(lhs...) // orig_rhs[0] was already evaluated } func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) { top := len(check.delayed) scope := check.scope // collect lhs variables seen := make(map[string]bool, len(lhs)) lhsVars := make([]*Var, len(lhs)) newVars := make([]*Var, 0, len(lhs)) hasErr := false for i, lhs := range lhs { ident, _ := lhs.(*syntax.Name) if ident == nil { check.useLHS(lhs) check.errorf(lhs, BadDecl, "non-name %s on left side of :=", lhs) hasErr = true continue } name := ident.Value if name != "_" { if seen[name] { check.errorf(lhs, RepeatedDecl, "%s repeated on left side of :=", lhs) hasErr = true continue } seen[name] = true } // Use the correct obj if the ident is redeclared. The // variable's scope starts after the declaration; so we // must use Scope.Lookup here and call Scope.Insert // (via check.declare) later. if alt := scope.Lookup(name); alt != nil { check.recordUse(ident, alt) // redeclared object must be a variable if obj, _ := alt.(*Var); obj != nil { lhsVars[i] = obj } else { check.errorf(lhs, UnassignableOperand, "cannot assign to %s", lhs) hasErr = true } continue } // declare new variable obj := NewVar(ident.Pos(), check.pkg, name, nil) lhsVars[i] = obj if name != "_" { newVars = append(newVars, obj) } check.recordDef(ident, obj) } // create dummy variables where the lhs is invalid for i, obj := range lhsVars { if obj == nil { lhsVars[i] = NewVar(lhs[i].Pos(), check.pkg, "_", nil) } } check.initVars(lhsVars, rhs, nil) // process function literals in rhs expressions before scope changes check.processDelayed(top) if len(newVars) == 0 && !hasErr { check.softErrorf(pos, NoNewVar, "no new variables on left side of :=") return } // declare new variables // spec: "The scope of a constant or variable identifier declared inside // a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl // for short variable declarations) and ends at the end of the innermost // containing block." scopePos := syntax.EndPos(rhs[len(rhs)-1]) for _, obj := range newVars { check.declare(scope, nil, obj, scopePos) // id = nil: recordDef already called } } PK ! ��~} selection.gonu �[��� // Copyright 2013 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. // This file implements Selections. package types2 import ( "bytes" "fmt" ) // SelectionKind describes the kind of a selector expression x.f // (excluding qualified identifiers). // // If x is a struct or *struct, a selector expression x.f may denote a // sequence of selection operations x.a.b.c.f. The SelectionKind // describes the kind of the final (explicit) operation; all the // previous (implicit) operations are always field selections. // Each element of Indices specifies an implicit field (a, b, c) // by its index in the struct type of the field selection operand. // // For a FieldVal operation, the final selection refers to the field // specified by Selection.Obj. // // For a MethodVal operation, the final selection refers to a method. // If the "pointerness" of the method's declared receiver does not // match that of the effective receiver after implicit field // selection, then an & or * operation is implicitly applied to the // receiver variable or value. // So, x.f denotes (&x.a.b.c).f when f requires a pointer receiver but // x.a.b.c is a non-pointer variable; and it denotes (*x.a.b.c).f when // f requires a non-pointer receiver but x.a.b.c is a pointer value. // // All pointer indirections, whether due to implicit or explicit field // selections or * operations inserted for "pointerness", panic if // applied to a nil pointer, so a method call x.f() may panic even // before the function call. // // By contrast, a MethodExpr operation T.f is essentially equivalent // to a function literal of the form: // // func(x T, args) (results) { return x.f(args) } // // Consequently, any implicit field selections and * operations // inserted for "pointerness" are not evaluated until the function is // called, so a T.f or (*T).f expression never panics. type SelectionKind int const ( FieldVal SelectionKind = iota // x.f is a struct field selector MethodVal // x.f is a method selector MethodExpr // x.f is a method expression ) // A Selection describes a selector expression x.f. // For the declarations: // // type T struct{ x int; E } // type E struct{} // func (e E) m() {} // var p *T // // the following relations exist: // // Selector Kind Recv Obj Type Index Indirect // // p.x FieldVal T x int {0} true // p.m MethodVal *T m func() {1, 0} true // T.m MethodExpr T m func(T) {1, 0} false type Selection struct { kind SelectionKind recv Type // type of x obj Object // object denoted by x.f index []int // path from x to x.f indirect bool // set if there was any pointer indirection on the path } // Kind returns the selection kind. func (s *Selection) Kind() SelectionKind { return s.kind } // Recv returns the type of x in x.f. func (s *Selection) Recv() Type { return s.recv } // Obj returns the object denoted by x.f; a *Var for // a field selection, and a *Func in all other cases. func (s *Selection) Obj() Object { return s.obj } // Type returns the type of x.f, which may be different from the type of f. // See Selection for more information. func (s *Selection) Type() Type { switch s.kind { case MethodVal: // The type of x.f is a method with its receiver type set // to the type of x. sig := *s.obj.(*Func).typ.(*Signature) recv := *sig.recv recv.typ = s.recv sig.recv = &recv return &sig case MethodExpr: // The type of x.f is a function (without receiver) // and an additional first argument with the same type as x. // TODO(gri) Similar code is already in call.go - factor! // TODO(gri) Compute this eagerly to avoid allocations. sig := *s.obj.(*Func).typ.(*Signature) arg0 := *sig.recv sig.recv = nil arg0.typ = s.recv var params []*Var if sig.params != nil { params = sig.params.vars } sig.params = NewTuple(append([]*Var{&arg0}, params...)...) return &sig } // In all other cases, the type of x.f is the type of x. return s.obj.Type() } // Index describes the path from x to f in x.f. // The last index entry is the field or method index of the type declaring f; // either: // // 1. the list of declared methods of a named type; or // 2. the list of methods of an interface type; or // 3. the list of fields of a struct type. // // The earlier index entries are the indices of the embedded fields implicitly // traversed to get from (the type of) x to f, starting at embedding depth 0. func (s *Selection) Index() []int { return s.index } // Indirect reports whether any pointer indirection was required to get from // x to f in x.f. // // Beware: Indirect spuriously returns true (Go issue #8353) for a // MethodVal selection in which the receiver argument and parameter // both have type *T so there is no indirection. // Unfortunately, a fix is too risky. func (s *Selection) Indirect() bool { return s.indirect } func (s *Selection) String() string { return SelectionString(s, nil) } // SelectionString returns the string form of s. // The Qualifier controls the printing of // package-level objects, and may be nil. // // Examples: // // "field (T) f int" // "method (T) f(X) Y" // "method expr (T) f(X) Y" func SelectionString(s *Selection, qf Qualifier) string { var k string switch s.kind { case FieldVal: k = "field " case MethodVal: k = "method " case MethodExpr: k = "method expr " default: unreachable() } var buf bytes.Buffer buf.WriteString(k) buf.WriteByte('(') WriteType(&buf, s.Recv(), qf) fmt.Fprintf(&buf, ") %s", s.obj.Name()) if T := s.Type(); s.kind == FieldVal { buf.WriteByte(' ') WriteType(&buf, T, qf) } else { WriteSignature(&buf, T.(*Signature), qf) } return buf.String() } PK ! UrI1� � util.gonu �[��� // Copyright 2023 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. // This file contains various functionality that is // different between go/types and types2. Factoring // out this code allows more of the rest of the code // to be shared. package types2 import "cmd/compile/internal/syntax" // cmpPos compares the positions p and q and returns a result r as follows: // // r < 0: p is before q // r == 0: p and q are the same position (but may not be identical) // r > 0: p is after q // // If p and q are in different files, p is before q if the filename // of p sorts lexicographically before the filename of q. func cmpPos(p, q syntax.Pos) int { return p.Cmp(q) } PK ! I��m m builtins.gonu �[��� // Copyright 2012 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. // This file implements typechecking of builtin function calls. package types2 import ( "cmd/compile/internal/syntax" "go/constant" "go/token" . "internal/types/errors" ) // builtin type-checks a call to the built-in specified by id and // reports whether the call is valid, with *x holding the result; // but x.expr is not set. If the call is invalid, the result is // false, and *x is undefined. func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (_ bool) { argList := call.ArgList // append is the only built-in that permits the use of ... for the last argument bin := predeclaredFuncs[id] if call.HasDots && id != _Append { //check.errorf(call.Ellipsis, invalidOp + "invalid use of ... with built-in %s", bin.name) check.errorf(call, InvalidDotDotDot, invalidOp+"invalid use of ... with built-in %s", bin.name) check.use(argList...) return } // For len(x) and cap(x) we need to know if x contains any function calls or // receive operations. Save/restore current setting and set hasCallOrRecv to // false for the evaluation of x so that we can check it afterwards. // Note: We must do this _before_ calling exprList because exprList evaluates // all arguments. if id == _Len || id == _Cap { defer func(b bool) { check.hasCallOrRecv = b }(check.hasCallOrRecv) check.hasCallOrRecv = false } // Evaluate arguments for built-ins that use ordinary (value) arguments. // For built-ins with special argument handling (make, new, etc.), // evaluation is done by the respective built-in code. var args []*operand // not valid for _Make, _New, _Offsetof, _Trace var nargs int switch id { default: // check all arguments args = check.exprList(argList) nargs = len(args) for _, a := range args { if a.mode == invalid { return } } // first argument is always in x if nargs > 0 { *x = *args[0] } case _Make, _New, _Offsetof, _Trace: // arguments require special handling nargs = len(argList) } // check argument count { msg := "" if nargs < bin.nargs { msg = "not enough" } else if !bin.variadic && nargs > bin.nargs { msg = "too many" } if msg != "" { check.errorf(call, WrongArgCount, invalidOp+"%s arguments for %v (expected %d, found %d)", msg, call, bin.nargs, nargs) return } } switch id { case _Append: // append(s S, x ...T) S, where T is the element type of S // spec: "The variadic function append appends zero or more values x to s of type // S, which must be a slice type, and returns the resulting slice, also of type S. // The values x are passed to a parameter of type ...T where T is the element type // of S and the respective parameter passing rules apply." S := x.typ var T Type if s, _ := coreType(S).(*Slice); s != nil { T = s.elem } else { var cause string switch { case x.isNil(): cause = "have untyped nil" case isTypeParam(S): if u := coreType(S); u != nil { cause = check.sprintf("%s has core type %s", x, u) } else { cause = check.sprintf("%s has no core type", x) } default: cause = check.sprintf("have %s", x) } // don't use invalidArg prefix here as it would repeat "argument" in the error message check.errorf(x, InvalidAppend, "first argument to append must be a slice; %s", cause) return } // spec: "As a special case, append also accepts a first argument assignable // to type []byte with a second argument of string type followed by ... . // This form appends the bytes of the string. if nargs == 2 && call.HasDots { if ok, _ := x.assignableTo(check, NewSlice(universeByte), nil); ok { y := args[1] if t := coreString(y.typ); t != nil && isString(t) { if check.recordTypes() { sig := makeSig(S, S, y.typ) sig.variadic = true check.recordBuiltinType(call.Fun, sig) } x.mode = value x.typ = S break } } } // check general case by creating custom signature sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature sig.variadic = true check.arguments(call, sig, nil, nil, args, nil, nil) // discard result (we know the result type) // ok to continue even if check.arguments reported errors x.mode = value x.typ = S if check.recordTypes() { check.recordBuiltinType(call.Fun, sig) } case _Cap, _Len: // cap(x) // len(x) mode := invalid var val constant.Value switch t := arrayPtrDeref(under(x.typ)).(type) { case *Basic: if isString(t) && id == _Len { if x.mode == constant_ { mode = constant_ val = constant.MakeInt64(int64(len(constant.StringVal(x.val)))) } else { mode = value } } case *Array: mode = value // spec: "The expressions len(s) and cap(s) are constants // if the type of s is an array or pointer to an array and // the expression s does not contain channel receives or // function calls; in this case s is not evaluated." if !check.hasCallOrRecv { mode = constant_ if t.len >= 0 { val = constant.MakeInt64(t.len) } else { val = constant.MakeUnknown() } } case *Slice, *Chan: mode = value case *Map: if id == _Len { mode = value } case *Interface: if !isTypeParam(x.typ) { break } if t.typeSet().underIs(func(t Type) bool { switch t := arrayPtrDeref(t).(type) { case *Basic: if isString(t) && id == _Len { return true } case *Array, *Slice, *Chan: return true case *Map: if id == _Len { return true } } return false }) { mode = value } } if mode == invalid { // avoid error if underlying type is invalid if isValid(under(x.typ)) { code := InvalidCap if id == _Len { code = InvalidLen } check.errorf(x, code, invalidArg+"%s for %s", x, bin.name) } return } // record the signature before changing x.typ if check.recordTypes() && mode != constant_ { check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ)) } x.mode = mode x.typ = Typ[Int] x.val = val case _Clear: // clear(m) check.verifyVersionf(call.Fun, go1_21, "clear") if !underIs(x.typ, func(u Type) bool { switch u.(type) { case *Map, *Slice: return true } check.errorf(x, InvalidClear, invalidArg+"cannot clear %s: argument must be (or constrained by) map or slice", x) return false }) { return } x.mode = novalue if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(nil, x.typ)) } case _Close: // close(c) if !underIs(x.typ, func(u Type) bool { uch, _ := u.(*Chan) if uch == nil { check.errorf(x, InvalidClose, invalidOp+"cannot close non-channel %s", x) return false } if uch.dir == RecvOnly { check.errorf(x, InvalidClose, invalidOp+"cannot close receive-only channel %s", x) return false } return true }) { return } x.mode = novalue if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(nil, x.typ)) } case _Complex: // complex(x, y floatT) complexT y := args[1] // convert or check untyped arguments d := 0 if isUntyped(x.typ) { d |= 1 } if isUntyped(y.typ) { d |= 2 } switch d { case 0: // x and y are typed => nothing to do case 1: // only x is untyped => convert to type of y check.convertUntyped(x, y.typ) case 2: // only y is untyped => convert to type of x check.convertUntyped(y, x.typ) case 3: // x and y are untyped => // 1) if both are constants, convert them to untyped // floating-point numbers if possible, // 2) if one of them is not constant (possible because // it contains a shift that is yet untyped), convert // both of them to float64 since they must have the // same type to succeed (this will result in an error // because shifts of floats are not permitted) if x.mode == constant_ && y.mode == constant_ { toFloat := func(x *operand) { if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 { x.typ = Typ[UntypedFloat] } } toFloat(x) toFloat(y) } else { check.convertUntyped(x, Typ[Float64]) check.convertUntyped(y, Typ[Float64]) // x and y should be invalid now, but be conservative // and check below } } if x.mode == invalid || y.mode == invalid { return } // both argument types must be identical if !Identical(x.typ, y.typ) { check.errorf(x, InvalidComplex, invalidOp+"%v (mismatched types %s and %s)", call, x.typ, y.typ) return } // the argument types must be of floating-point type // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(!isTypeParam(typ)) if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Float32: return Typ[Complex64] case Float64: return Typ[Complex128] case UntypedFloat: return Typ[UntypedComplex] } } return nil } resTyp := check.applyTypeFunc(f, x, id) if resTyp == nil { check.errorf(x, InvalidComplex, invalidArg+"arguments have type %s, expected floating-point", x.typ) return } // if both arguments are constants, the result is a constant if x.mode == constant_ && y.mode == constant_ { x.val = constant.BinaryOp(constant.ToFloat(x.val), token.ADD, constant.MakeImag(constant.ToFloat(y.val))) } else { x.mode = value } if check.recordTypes() && x.mode != constant_ { check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ)) } x.typ = resTyp case _Copy: // copy(x, y []T) int dst, _ := coreType(x.typ).(*Slice) y := args[1] src0 := coreString(y.typ) if src0 != nil && isString(src0) { src0 = NewSlice(universeByte) } src, _ := src0.(*Slice) if dst == nil || src == nil { check.errorf(x, InvalidCopy, invalidArg+"copy expects slice arguments; found %s and %s", x, y) return } if !Identical(dst.elem, src.elem) { check.errorf(x, InvalidCopy, invalidArg+"arguments to copy %s and %s have different element types %s and %s", x, y, dst.elem, src.elem) return } if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ)) } x.mode = value x.typ = Typ[Int] case _Delete: // delete(map_, key) // map_ must be a map type or a type parameter describing map types. // The key cannot be a type parameter for now. map_ := x.typ var key Type if !underIs(map_, func(u Type) bool { map_, _ := u.(*Map) if map_ == nil { check.errorf(x, InvalidDelete, invalidArg+"%s is not a map", x) return false } if key != nil && !Identical(map_.key, key) { check.errorf(x, InvalidDelete, invalidArg+"maps of %s must have identical key types", x) return false } key = map_.key return true }) { return } *x = *args[1] // key check.assignment(x, key, "argument to delete") if x.mode == invalid { return } x.mode = novalue if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(nil, map_, key)) } case _Imag, _Real: // imag(complexT) floatT // real(complexT) floatT // convert or check untyped argument if isUntyped(x.typ) { if x.mode == constant_ { // an untyped constant number can always be considered // as a complex constant if isNumeric(x.typ) { x.typ = Typ[UntypedComplex] } } else { // an untyped non-constant argument may appear if // it contains a (yet untyped non-constant) shift // expression: convert it to complex128 which will // result in an error (shift of complex value) check.convertUntyped(x, Typ[Complex128]) // x should be invalid now, but be conservative and check if x.mode == invalid { return } } } // the argument must be of complex type // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(!isTypeParam(typ)) if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Complex64: return Typ[Float32] case Complex128: return Typ[Float64] case UntypedComplex: return Typ[UntypedFloat] } } return nil } resTyp := check.applyTypeFunc(f, x, id) if resTyp == nil { code := InvalidImag if id == _Real { code = InvalidReal } check.errorf(x, code, invalidArg+"argument has type %s, expected complex type", x.typ) return } // if the argument is a constant, the result is a constant if x.mode == constant_ { if id == _Real { x.val = constant.Real(x.val) } else { x.val = constant.Imag(x.val) } } else { x.mode = value } if check.recordTypes() && x.mode != constant_ { check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ)) } x.typ = resTyp case _Make: // make(T, n) // make(T, n, m) // (no argument evaluated yet) arg0 := argList[0] T := check.varType(arg0) if !isValid(T) { return } var min int // minimum number of arguments switch coreType(T).(type) { case *Slice: min = 2 case *Map, *Chan: min = 1 case nil: check.errorf(arg0, InvalidMake, invalidArg+"cannot make %s: no core type", arg0) return default: check.errorf(arg0, InvalidMake, invalidArg+"cannot make %s; type must be slice, map, or channel", arg0) return } if nargs < min || min+1 < nargs { check.errorf(call, WrongArgCount, invalidOp+"%v expects %d or %d arguments; found %d", call, min, min+1, nargs) return } types := []Type{T} var sizes []int64 // constant integer arguments, if any for _, arg := range argList[1:] { typ, size := check.index(arg, -1) // ok to continue with typ == Typ[Invalid] types = append(types, typ) if size >= 0 { sizes = append(sizes, size) } } if len(sizes) == 2 && sizes[0] > sizes[1] { check.error(argList[1], SwappedMakeArgs, invalidArg+"length and capacity swapped") // safe to continue } x.mode = value x.typ = T if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, types...)) } case _Max, _Min: // max(x, ...) // min(x, ...) check.verifyVersionf(call.Fun, go1_21, bin.name) op := token.LSS if id == _Max { op = token.GTR } for i, a := range args { if a.mode == invalid { return } if !allOrdered(a.typ) { check.errorf(a, InvalidMinMaxOperand, invalidArg+"%s cannot be ordered", a) return } // The first argument is already in x and there's nothing left to do. if i > 0 { check.matchTypes(x, a) if x.mode == invalid { return } if !Identical(x.typ, a.typ) { check.errorf(a, MismatchedTypes, invalidArg+"mismatched types %s (previous argument) and %s (type of %s)", x.typ, a.typ, a.expr) return } if x.mode == constant_ && a.mode == constant_ { if constant.Compare(a.val, op, x.val) { *x = *a } } else { x.mode = value } } } // If nargs == 1, make sure x.mode is either a value or a constant. if x.mode != constant_ { x.mode = value // A value must not be untyped. check.assignment(x, &emptyInterface, "argument to "+bin.name) if x.mode == invalid { return } } // Use the final type computed above for all arguments. for _, a := range args { check.updateExprType(a.expr, x.typ, true) } if check.recordTypes() && x.mode != constant_ { types := make([]Type, nargs) for i := range types { types[i] = x.typ } check.recordBuiltinType(call.Fun, makeSig(x.typ, types...)) } case _New: // new(T) // (no argument evaluated yet) T := check.varType(argList[0]) if !isValid(T) { return } x.mode = value x.typ = &Pointer{base: T} if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, T)) } case _Panic: // panic(x) // record panic call if inside a function with result parameters // (for use in Checker.isTerminating) if check.sig != nil && check.sig.results.Len() > 0 { // function has result parameters p := check.isPanic if p == nil { // allocate lazily p = make(map[*syntax.CallExpr]bool) check.isPanic = p } p[call] = true } check.assignment(x, &emptyInterface, "argument to panic") if x.mode == invalid { return } x.mode = novalue if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(nil, &emptyInterface)) } case _Print, _Println: // print(x, y, ...) // println(x, y, ...) var params []Type if nargs > 0 { params = make([]Type, nargs) for i, a := range args { check.assignment(a, nil, "argument to "+predeclaredFuncs[id].name) if a.mode == invalid { return } params[i] = a.typ } } x.mode = novalue if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(nil, params...)) } case _Recover: // recover() interface{} x.mode = value x.typ = &emptyInterface if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ)) } case _Add: // unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer check.verifyVersionf(call.Fun, go1_17, "unsafe.Add") check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add") if x.mode == invalid { return } y := args[1] if !check.isValidIndex(y, InvalidUnsafeAdd, "length", true) { return } x.mode = value x.typ = Typ[UnsafePointer] if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, x.typ, y.typ)) } case _Alignof: // unsafe.Alignof(x T) uintptr check.assignment(x, nil, "argument to unsafe.Alignof") if x.mode == invalid { return } if hasVarSize(x.typ, nil) { x.mode = value if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], x.typ)) } } else { x.mode = constant_ x.val = constant.MakeInt64(check.conf.alignof(x.typ)) // result is constant - no need to record signature } x.typ = Typ[Uintptr] case _Offsetof: // unsafe.Offsetof(x T) uintptr, where x must be a selector // (no argument evaluated yet) arg0 := argList[0] selx, _ := syntax.Unparen(arg0).(*syntax.SelectorExpr) if selx == nil { check.errorf(arg0, BadOffsetofSyntax, invalidArg+"%s is not a selector expression", arg0) check.use(arg0) return } check.expr(nil, x, selx.X) if x.mode == invalid { return } base := derefStructPtr(x.typ) sel := selx.Sel.Value obj, index, indirect := LookupFieldOrMethod(base, false, check.pkg, sel) switch obj.(type) { case nil: check.errorf(x, MissingFieldOrMethod, invalidArg+"%s has no single field %s", base, sel) return case *Func: // TODO(gri) Using derefStructPtr may result in methods being found // that don't actually exist. An error either way, but the error // message is confusing. See: https://play.golang.org/p/al75v23kUy , // but go/types reports: "invalid argument: x.m is a method value". check.errorf(arg0, InvalidOffsetof, invalidArg+"%s is a method value", arg0) return } if indirect { check.errorf(x, InvalidOffsetof, invalidArg+"field %s is embedded via a pointer in %s", sel, base) return } // TODO(gri) Should we pass x.typ instead of base (and have indirect report if derefStructPtr indirected)? check.recordSelection(selx, FieldVal, base, obj, index, false) // record the selector expression (was bug - go.dev/issue/47895) { mode := value if x.mode == variable || indirect { mode = variable } check.record(&operand{mode, selx, obj.Type(), nil, 0}) } // The field offset is considered a variable even if the field is declared before // the part of the struct which is variable-sized. This makes both the rules // simpler and also permits (or at least doesn't prevent) a compiler from re- // arranging struct fields if it wanted to. if hasVarSize(base, nil) { x.mode = value if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], obj.Type())) } } else { offs := check.conf.offsetof(base, index) if offs < 0 { check.errorf(x, TypeTooLarge, "%s is too large", x) return } x.mode = constant_ x.val = constant.MakeInt64(offs) // result is constant - no need to record signature } x.typ = Typ[Uintptr] case _Sizeof: // unsafe.Sizeof(x T) uintptr check.assignment(x, nil, "argument to unsafe.Sizeof") if x.mode == invalid { return } if hasVarSize(x.typ, nil) { x.mode = value if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], x.typ)) } } else { size := check.conf.sizeof(x.typ) if size < 0 { check.errorf(x, TypeTooLarge, "%s is too large", x) return } x.mode = constant_ x.val = constant.MakeInt64(size) // result is constant - no need to record signature } x.typ = Typ[Uintptr] case _Slice: // unsafe.Slice(ptr *T, len IntegerType) []T check.verifyVersionf(call.Fun, go1_17, "unsafe.Slice") ptr, _ := coreType(x.typ).(*Pointer) if ptr == nil { check.errorf(x, InvalidUnsafeSlice, invalidArg+"%s is not a pointer", x) return } y := args[1] if !check.isValidIndex(y, InvalidUnsafeSlice, "length", false) { return } x.mode = value x.typ = NewSlice(ptr.base) if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, ptr, y.typ)) } case _SliceData: // unsafe.SliceData(slice []T) *T check.verifyVersionf(call.Fun, go1_20, "unsafe.SliceData") slice, _ := coreType(x.typ).(*Slice) if slice == nil { check.errorf(x, InvalidUnsafeSliceData, invalidArg+"%s is not a slice", x) return } x.mode = value x.typ = NewPointer(slice.elem) if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, slice)) } case _String: // unsafe.String(ptr *byte, len IntegerType) string check.verifyVersionf(call.Fun, go1_20, "unsafe.String") check.assignment(x, NewPointer(universeByte), "argument to unsafe.String") if x.mode == invalid { return } y := args[1] if !check.isValidIndex(y, InvalidUnsafeString, "length", false) { return } x.mode = value x.typ = Typ[String] if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, NewPointer(universeByte), y.typ)) } case _StringData: // unsafe.StringData(str string) *byte check.verifyVersionf(call.Fun, go1_20, "unsafe.StringData") check.assignment(x, Typ[String], "argument to unsafe.StringData") if x.mode == invalid { return } x.mode = value x.typ = NewPointer(universeByte) if check.recordTypes() { check.recordBuiltinType(call.Fun, makeSig(x.typ, Typ[String])) } case _Assert: // assert(pred) causes a typechecker error if pred is false. // The result of assert is the value of pred if there is no error. // Note: assert is only available in self-test mode. if x.mode != constant_ || !isBoolean(x.typ) { check.errorf(x, Test, invalidArg+"%s is not a boolean constant", x) return } if x.val.Kind() != constant.Bool { check.errorf(x, Test, "internal error: value of %s should be a boolean constant", x) return } if !constant.BoolVal(x.val) { check.errorf(call, Test, "%v failed", call) // compile-time assertion failure - safe to continue } // result is constant - no need to record signature case _Trace: // trace(x, y, z, ...) dumps the positions, expressions, and // values of its arguments. The result of trace is the value // of the first argument. // Note: trace is only available in self-test mode. // (no argument evaluated yet) if nargs == 0 { check.dump("%v: trace() without arguments", atPos(call)) x.mode = novalue break } var t operand x1 := x for _, arg := range argList { check.rawExpr(nil, x1, arg, nil, false) // permit trace for types, e.g.: new(trace(T)) check.dump("%v: %s", atPos(x1), x1) x1 = &t // use incoming x only for first argument } if x.mode == invalid { return } // trace is only available in test mode - no need to record signature default: unreachable() } assert(x.mode != invalid) return true } // hasVarSize reports if the size of type t is variable due to type parameters // or if the type is infinitely-sized due to a cycle for which the type has not // yet been checked. func hasVarSize(t Type, seen map[*Named]bool) (varSized bool) { // Cycles are only possible through *Named types. // The seen map is used to detect cycles and track // the results of previously seen types. if named := asNamed(t); named != nil { if v, ok := seen[named]; ok { return v } if seen == nil { seen = make(map[*Named]bool) } seen[named] = true // possibly cyclic until proven otherwise defer func() { seen[named] = varSized // record final determination for named }() } switch u := under(t).(type) { case *Array: return hasVarSize(u.elem, seen) case *Struct: for _, f := range u.fields { if hasVarSize(f.typ, seen) { return true } } case *Interface: return isTypeParam(t) case *Named, *Union: unreachable() } return false } // applyTypeFunc applies f to x. If x is a type parameter, // the result is a type parameter constrained by a new // interface bound. The type bounds for that interface // are computed by applying f to each of the type bounds // of x. If any of these applications of f return nil, // applyTypeFunc returns nil. // If x is not a type parameter, the result is f(x). func (check *Checker) applyTypeFunc(f func(Type) Type, x *operand, id builtinId) Type { if tp, _ := x.typ.(*TypeParam); tp != nil { // Test if t satisfies the requirements for the argument // type and collect possible result types at the same time. var terms []*Term if !tp.is(func(t *term) bool { if t == nil { return false } if r := f(t.typ); r != nil { terms = append(terms, NewTerm(t.tilde, r)) return true } return false }) { return nil } // We can type-check this fine but we're introducing a synthetic // type parameter for the result. It's not clear what the API // implications are here. Report an error for 1.18 (see go.dev/issue/50912), // but continue type-checking. var code Code switch id { case _Real: code = InvalidReal case _Imag: code = InvalidImag case _Complex: code = InvalidComplex default: unreachable() } check.softErrorf(x, code, "%s not supported as argument to %s for go1.18 (see go.dev/issue/50937)", x, predeclaredFuncs[id].name) // Construct a suitable new type parameter for the result type. // The type parameter is placed in the current package so export/import // works as expected. tpar := NewTypeName(nopos, check.pkg, tp.obj.name, nil) ptyp := check.newTypeParam(tpar, NewInterfaceType(nil, []Type{NewUnion(terms)})) // assigns type to tpar as a side-effect ptyp.index = tp.index return ptyp } return f(x.typ) } // makeSig makes a signature for the given argument and result types. // Default types are used for untyped arguments, and res may be nil. func makeSig(res Type, args ...Type) *Signature { list := make([]*Var, len(args)) for i, param := range args { list[i] = NewVar(nopos, nil, "", Default(param)) } params := NewTuple(list...) var result *Tuple if res != nil { assert(!isUntyped(res)) result = NewTuple(NewVar(nopos, nil, "", res)) } return &Signature{params: params, results: result} } // arrayPtrDeref returns A if typ is of the form *A and A is an array; // otherwise it returns typ. func arrayPtrDeref(typ Type) Type { if p, ok := typ.(*Pointer); ok { if a, _ := under(p.base).(*Array); a != nil { return a } } return typ } // unparen returns e with any enclosing parentheses stripped. func unparen(e syntax.Expr) syntax.Expr { for { p, ok := e.(*syntax.ParenExpr) if !ok { return e } e = p.X } } PK ! B�%�^ ^ sizes_test.gonu �[��� // Copyright 2016 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. // This file contains tests for sizes. package types2_test import ( "cmd/compile/internal/syntax" "cmd/compile/internal/types2" "internal/testenv" "testing" ) // findStructType typechecks src and returns the first struct type encountered. func findStructType(t *testing.T, src string) *types2.Struct { return findStructTypeConfig(t, src, &types2.Config{}) } func findStructTypeConfig(t *testing.T, src string, conf *types2.Config) *types2.Struct { types := make(map[syntax.Expr]types2.TypeAndValue) mustTypecheck(src, nil, &types2.Info{Types: types}) for _, tv := range types { if ts, ok := tv.Type.(*types2.Struct); ok { return ts } } t.Fatalf("failed to find a struct type in src:\n%s\n", src) return nil } // go.dev/issue/16316 func TestMultipleSizeUse(t *testing.T) { const src = ` package main type S struct { i int b bool s string n int } ` ts := findStructType(t, src) sizes := types2.StdSizes{WordSize: 4, MaxAlign: 4} if got := sizes.Sizeof(ts); got != 20 { t.Errorf("Sizeof(%v) with WordSize 4 = %d want 20", ts, got) } sizes = types2.StdSizes{WordSize: 8, MaxAlign: 8} if got := sizes.Sizeof(ts); got != 40 { t.Errorf("Sizeof(%v) with WordSize 8 = %d want 40", ts, got) } } // go.dev/issue/16464 func TestAlignofNaclSlice(t *testing.T) { const src = ` package main var s struct { x *int y []byte } ` ts := findStructType(t, src) sizes := &types2.StdSizes{WordSize: 4, MaxAlign: 8} var fields []*types2.Var // Make a copy manually :( for i := 0; i < ts.NumFields(); i++ { fields = append(fields, ts.Field(i)) } offsets := sizes.Offsetsof(fields) if offsets[0] != 0 || offsets[1] != 4 { t.Errorf("OffsetsOf(%v) = %v want %v", ts, offsets, []int{0, 4}) } } func TestIssue16902(t *testing.T) { const src = ` package a import "unsafe" const _ = unsafe.Offsetof(struct{ x int64 }{}.x) ` info := types2.Info{Types: make(map[syntax.Expr]types2.TypeAndValue)} conf := types2.Config{ Importer: defaultImporter(), Sizes: &types2.StdSizes{WordSize: 8, MaxAlign: 8}, } mustTypecheck(src, &conf, &info) for _, tv := range info.Types { _ = conf.Sizes.Sizeof(tv.Type) _ = conf.Sizes.Alignof(tv.Type) } } // go.dev/issue/53884. func TestAtomicAlign(t *testing.T) { testenv.MustHaveGoBuild(t) // The Go command is needed for the importer to determine the locations of stdlib .a files. const src = ` package main import "sync/atomic" var s struct { x int32 y atomic.Int64 z int64 } ` want := []int64{0, 8, 16} for _, arch := range []string{"386", "amd64"} { t.Run(arch, func(t *testing.T) { conf := types2.Config{ Importer: defaultImporter(), Sizes: types2.SizesFor("gc", arch), } ts := findStructTypeConfig(t, src, &conf) var fields []*types2.Var // Make a copy manually :( for i := 0; i < ts.NumFields(); i++ { fields = append(fields, ts.Field(i)) } offsets := conf.Sizes.Offsetsof(fields) if offsets[0] != want[0] || offsets[1] != want[1] || offsets[2] != want[2] { t.Errorf("OffsetsOf(%v) = %v want %v", ts, offsets, want) } }) } } type gcSizeTest struct { name string src string } var gcSizesTests = []gcSizeTest{ { "issue60431", ` package main import "unsafe" // The foo struct size is expected to be rounded up to 16 bytes. type foo struct { a int64 b bool } func main() { assert(unsafe.Sizeof(foo{}) == 16) }`, }, { "issue60734", ` package main import ( "unsafe" ) // The Data struct size is expected to be rounded up to 16 bytes. type Data struct { Value uint32 // 4 bytes Label [10]byte // 10 bytes Active bool // 1 byte // padded with 1 byte to make it align } func main() { assert(unsafe.Sizeof(Data{}) == 16) } `, }, } func TestGCSizes(t *testing.T) { types2.DefPredeclaredTestFuncs() for _, tc := range gcSizesTests { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() conf := types2.Config{Importer: defaultImporter(), Sizes: types2.SizesFor("gc", "amd64")} mustTypecheck(tc.src, &conf, nil) }) } } PK ! I C+[h [h api_test.gonu �[��� // Copyright 2013 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 types2_test import ( "cmd/compile/internal/syntax" "errors" "fmt" "internal/goversion" "internal/testenv" "reflect" "regexp" "sort" "strings" "sync" "testing" . "cmd/compile/internal/types2" ) // nopos indicates an unknown position var nopos syntax.Pos func mustParse(src string) *syntax.File { f, err := syntax.Parse(syntax.NewFileBase(pkgName(src)), strings.NewReader(src), nil, nil, 0) if err != nil { panic(err) // so we don't need to pass *testing.T } return f } func typecheck(src string, conf *Config, info *Info) (*Package, error) { f := mustParse(src) if conf == nil { conf = &Config{ Error: func(err error) {}, // collect all errors Importer: defaultImporter(), } } return conf.Check(f.PkgName.Value, []*syntax.File{f}, info) } func mustTypecheck(src string, conf *Config, info *Info) *Package { pkg, err := typecheck(src, conf, info) if err != nil { panic(err) // so we don't need to pass *testing.T } return pkg } // pkgName extracts the package name from src, which must contain a package header. func pkgName(src string) string { const kw = "package " if i := strings.Index(src, kw); i >= 0 { after := src[i+len(kw):] n := len(after) if i := strings.IndexAny(after, "\n\t ;/"); i >= 0 { n = i } return after[:n] } panic("missing package header: " + src) } func TestValuesInfo(t *testing.T) { var tests = []struct { src string expr string // constant expression typ string // constant type val string // constant value }{ {`package a0; const _ = false`, `false`, `untyped bool`, `false`}, {`package a1; const _ = 0`, `0`, `untyped int`, `0`}, {`package a2; const _ = 'A'`, `'A'`, `untyped rune`, `65`}, {`package a3; const _ = 0.`, `0.`, `untyped float`, `0`}, {`package a4; const _ = 0i`, `0i`, `untyped complex`, `(0 + 0i)`}, {`package a5; const _ = "foo"`, `"foo"`, `untyped string`, `"foo"`}, {`package b0; var _ = false`, `false`, `bool`, `false`}, {`package b1; var _ = 0`, `0`, `int`, `0`}, {`package b2; var _ = 'A'`, `'A'`, `rune`, `65`}, {`package b3; var _ = 0.`, `0.`, `float64`, `0`}, {`package b4; var _ = 0i`, `0i`, `complex128`, `(0 + 0i)`}, {`package b5; var _ = "foo"`, `"foo"`, `string`, `"foo"`}, {`package c0a; var _ = bool(false)`, `false`, `bool`, `false`}, {`package c0b; var _ = bool(false)`, `bool(false)`, `bool`, `false`}, {`package c0c; type T bool; var _ = T(false)`, `T(false)`, `c0c.T`, `false`}, {`package c1a; var _ = int(0)`, `0`, `int`, `0`}, {`package c1b; var _ = int(0)`, `int(0)`, `int`, `0`}, {`package c1c; type T int; var _ = T(0)`, `T(0)`, `c1c.T`, `0`}, {`package c2a; var _ = rune('A')`, `'A'`, `rune`, `65`}, {`package c2b; var _ = rune('A')`, `rune('A')`, `rune`, `65`}, {`package c2c; type T rune; var _ = T('A')`, `T('A')`, `c2c.T`, `65`}, {`package c3a; var _ = float32(0.)`, `0.`, `float32`, `0`}, {`package c3b; var _ = float32(0.)`, `float32(0.)`, `float32`, `0`}, {`package c3c; type T float32; var _ = T(0.)`, `T(0.)`, `c3c.T`, `0`}, {`package c4a; var _ = complex64(0i)`, `0i`, `complex64`, `(0 + 0i)`}, {`package c4b; var _ = complex64(0i)`, `complex64(0i)`, `complex64`, `(0 + 0i)`}, {`package c4c; type T complex64; var _ = T(0i)`, `T(0i)`, `c4c.T`, `(0 + 0i)`}, {`package c5a; var _ = string("foo")`, `"foo"`, `string`, `"foo"`}, {`package c5b; var _ = string("foo")`, `string("foo")`, `string`, `"foo"`}, {`package c5c; type T string; var _ = T("foo")`, `T("foo")`, `c5c.T`, `"foo"`}, {`package c5d; var _ = string(65)`, `65`, `untyped int`, `65`}, {`package c5e; var _ = string('A')`, `'A'`, `untyped rune`, `65`}, {`package c5f; type T string; var _ = T('A')`, `'A'`, `untyped rune`, `65`}, {`package d0; var _ = []byte("foo")`, `"foo"`, `string`, `"foo"`}, {`package d1; var _ = []byte(string("foo"))`, `"foo"`, `string`, `"foo"`}, {`package d2; var _ = []byte(string("foo"))`, `string("foo")`, `string`, `"foo"`}, {`package d3; type T []byte; var _ = T("foo")`, `"foo"`, `string`, `"foo"`}, {`package e0; const _ = float32( 1e-200)`, `float32(1e-200)`, `float32`, `0`}, {`package e1; const _ = float32(-1e-200)`, `float32(-1e-200)`, `float32`, `0`}, {`package e2; const _ = float64( 1e-2000)`, `float64(1e-2000)`, `float64`, `0`}, {`package e3; const _ = float64(-1e-2000)`, `float64(-1e-2000)`, `float64`, `0`}, {`package e4; const _ = complex64( 1e-200)`, `complex64(1e-200)`, `complex64`, `(0 + 0i)`}, {`package e5; const _ = complex64(-1e-200)`, `complex64(-1e-200)`, `complex64`, `(0 + 0i)`}, {`package e6; const _ = complex128( 1e-2000)`, `complex128(1e-2000)`, `complex128`, `(0 + 0i)`}, {`package e7; const _ = complex128(-1e-2000)`, `complex128(-1e-2000)`, `complex128`, `(0 + 0i)`}, {`package f0 ; var _ float32 = 1e-200`, `1e-200`, `float32`, `0`}, {`package f1 ; var _ float32 = -1e-200`, `-1e-200`, `float32`, `0`}, {`package f2a; var _ float64 = 1e-2000`, `1e-2000`, `float64`, `0`}, {`package f3a; var _ float64 = -1e-2000`, `-1e-2000`, `float64`, `0`}, {`package f2b; var _ = 1e-2000`, `1e-2000`, `float64`, `0`}, {`package f3b; var _ = -1e-2000`, `-1e-2000`, `float64`, `0`}, {`package f4 ; var _ complex64 = 1e-200 `, `1e-200`, `complex64`, `(0 + 0i)`}, {`package f5 ; var _ complex64 = -1e-200 `, `-1e-200`, `complex64`, `(0 + 0i)`}, {`package f6a; var _ complex128 = 1e-2000i`, `1e-2000i`, `complex128`, `(0 + 0i)`}, {`package f7a; var _ complex128 = -1e-2000i`, `-1e-2000i`, `complex128`, `(0 + 0i)`}, {`package f6b; var _ = 1e-2000i`, `1e-2000i`, `complex128`, `(0 + 0i)`}, {`package f7b; var _ = -1e-2000i`, `-1e-2000i`, `complex128`, `(0 + 0i)`}, {`package g0; const (a = len([iota]int{}); b; c); const _ = c`, `c`, `int`, `2`}, // go.dev/issue/22341 {`package g1; var(j int32; s int; n = 1.0<<s == j)`, `1.0`, `int32`, `1`}, // go.dev/issue/48422 } for _, test := range tests { info := Info{ Types: make(map[syntax.Expr]TypeAndValue), } name := mustTypecheck(test.src, nil, &info).Name() // look for expression var expr syntax.Expr for e := range info.Types { if syntax.String(e) == test.expr { expr = e break } } if expr == nil { t.Errorf("package %s: no expression found for %s", name, test.expr) continue } tv := info.Types[expr] // check that type is correct if got := tv.Type.String(); got != test.typ { t.Errorf("package %s: got type %s; want %s", name, got, test.typ) continue } // if we have a constant, check that value is correct if tv.Value != nil { if got := tv.Value.ExactString(); got != test.val { t.Errorf("package %s: got value %s; want %s", name, got, test.val) } } else { if test.val != "" { t.Errorf("package %s: no constant found; want %s", name, test.val) } } } } func TestTypesInfo(t *testing.T) { // Test sources that are not expected to typecheck must start with the broken prefix. const brokenPkg = "package broken_" var tests = []struct { src string expr string // expression typ string // value type }{ // single-valued expressions of untyped constants {`package b0; var x interface{} = false`, `false`, `bool`}, {`package b1; var x interface{} = 0`, `0`, `int`}, {`package b2; var x interface{} = 0.`, `0.`, `float64`}, {`package b3; var x interface{} = 0i`, `0i`, `complex128`}, {`package b4; var x interface{} = "foo"`, `"foo"`, `string`}, // uses of nil {`package n0; var _ *int = nil`, `nil`, `*int`}, {`package n1; var _ func() = nil`, `nil`, `func()`}, {`package n2; var _ []byte = nil`, `nil`, `[]byte`}, {`package n3; var _ map[int]int = nil`, `nil`, `map[int]int`}, {`package n4; var _ chan int = nil`, `nil`, `chan int`}, {`package n5a; var _ interface{} = (*int)(nil)`, `nil`, `*int`}, {`package n5b; var _ interface{m()} = nil`, `nil`, `interface{m()}`}, {`package n6; import "unsafe"; var _ unsafe.Pointer = nil`, `nil`, `unsafe.Pointer`}, {`package n10; var (x *int; _ = x == nil)`, `nil`, `*int`}, {`package n11; var (x func(); _ = x == nil)`, `nil`, `func()`}, {`package n12; var (x []byte; _ = x == nil)`, `nil`, `[]byte`}, {`package n13; var (x map[int]int; _ = x == nil)`, `nil`, `map[int]int`}, {`package n14; var (x chan int; _ = x == nil)`, `nil`, `chan int`}, {`package n15a; var (x interface{}; _ = x == (*int)(nil))`, `nil`, `*int`}, {`package n15b; var (x interface{m()}; _ = x == nil)`, `nil`, `interface{m()}`}, {`package n15; import "unsafe"; var (x unsafe.Pointer; _ = x == nil)`, `nil`, `unsafe.Pointer`}, {`package n20; var _ = (*int)(nil)`, `nil`, `*int`}, {`package n21; var _ = (func())(nil)`, `nil`, `func()`}, {`package n22; var _ = ([]byte)(nil)`, `nil`, `[]byte`}, {`package n23; var _ = (map[int]int)(nil)`, `nil`, `map[int]int`}, {`package n24; var _ = (chan int)(nil)`, `nil`, `chan int`}, {`package n25a; var _ = (interface{})((*int)(nil))`, `nil`, `*int`}, {`package n25b; var _ = (interface{m()})(nil)`, `nil`, `interface{m()}`}, {`package n26; import "unsafe"; var _ = unsafe.Pointer(nil)`, `nil`, `unsafe.Pointer`}, {`package n30; func f(*int) { f(nil) }`, `nil`, `*int`}, {`package n31; func f(func()) { f(nil) }`, `nil`, `func()`}, {`package n32; func f([]byte) { f(nil) }`, `nil`, `[]byte`}, {`package n33; func f(map[int]int) { f(nil) }`, `nil`, `map[int]int`}, {`package n34; func f(chan int) { f(nil) }`, `nil`, `chan int`}, {`package n35a; func f(interface{}) { f((*int)(nil)) }`, `nil`, `*int`}, {`package n35b; func f(interface{m()}) { f(nil) }`, `nil`, `interface{m()}`}, {`package n35; import "unsafe"; func f(unsafe.Pointer) { f(nil) }`, `nil`, `unsafe.Pointer`}, // comma-ok expressions {`package p0; var x interface{}; var _, _ = x.(int)`, `x.(int)`, `(int, bool)`, }, {`package p1; var x interface{}; func _() { _, _ = x.(int) }`, `x.(int)`, `(int, bool)`, }, {`package p2a; type mybool bool; var m map[string]complex128; var b mybool; func _() { _, b = m["foo"] }`, `m["foo"]`, `(complex128, p2a.mybool)`, }, {`package p2b; var m map[string]complex128; var b bool; func _() { _, b = m["foo"] }`, `m["foo"]`, `(complex128, bool)`, }, {`package p3; var c chan string; var _, _ = <-c`, `<-c`, `(string, bool)`, }, // go.dev/issue/6796 {`package issue6796_a; var x interface{}; var _, _ = (x.(int))`, `x.(int)`, `(int, bool)`, }, {`package issue6796_b; var c chan string; var _, _ = (<-c)`, `(<-c)`, `(string, bool)`, }, {`package issue6796_c; var c chan string; var _, _ = (<-c)`, `<-c`, `(string, bool)`, }, {`package issue6796_d; var c chan string; var _, _ = ((<-c))`, `(<-c)`, `(string, bool)`, }, {`package issue6796_e; func f(c chan string) { _, _ = ((<-c)) }`, `(<-c)`, `(string, bool)`, }, // go.dev/issue/7060 {`package issue7060_a; var ( m map[int]string; x, ok = m[0] )`, `m[0]`, `(string, bool)`, }, {`package issue7060_b; var ( m map[int]string; x, ok interface{} = m[0] )`, `m[0]`, `(string, bool)`, }, {`package issue7060_c; func f(x interface{}, ok bool, m map[int]string) { x, ok = m[0] }`, `m[0]`, `(string, bool)`, }, {`package issue7060_d; var ( ch chan string; x, ok = <-ch )`, `<-ch`, `(string, bool)`, }, {`package issue7060_e; var ( ch chan string; x, ok interface{} = <-ch )`, `<-ch`, `(string, bool)`, }, {`package issue7060_f; func f(x interface{}, ok bool, ch chan string) { x, ok = <-ch }`, `<-ch`, `(string, bool)`, }, // go.dev/issue/28277 {`package issue28277_a; func f(...int)`, `...int`, `[]int`, }, {`package issue28277_b; func f(a, b int, c ...[]struct{})`, `...[]struct{}`, `[][]struct{}`, }, // go.dev/issue/47243 {`package issue47243_a; var x int32; var _ = x << 3`, `3`, `untyped int`}, {`package issue47243_b; var x int32; var _ = x << 3.`, `3.`, `untyped float`}, {`package issue47243_c; var x int32; var _ = 1 << x`, `1 << x`, `int`}, {`package issue47243_d; var x int32; var _ = 1 << x`, `1`, `int`}, {`package issue47243_e; var x int32; var _ = 1 << 2`, `1`, `untyped int`}, {`package issue47243_f; var x int32; var _ = 1 << 2`, `2`, `untyped int`}, {`package issue47243_g; var x int32; var _ = int(1) << 2`, `2`, `untyped int`}, {`package issue47243_h; var x int32; var _ = 1 << (2 << x)`, `1`, `int`}, {`package issue47243_i; var x int32; var _ = 1 << (2 << x)`, `(2 << x)`, `untyped int`}, {`package issue47243_j; var x int32; var _ = 1 << (2 << x)`, `2`, `untyped int`}, // tests for broken code that doesn't type-check {brokenPkg + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`}, {brokenPkg + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`}, {brokenPkg + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`}, {brokenPkg + `x3; var x = panic("");`, `panic`, `func(interface{})`}, {`package x4; func _() { panic("") }`, `panic`, `func(interface{})`}, {brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string]invalid type`}, // parameterized functions {`package p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T any](T)`}, {`package p1; func f[T any](T) {}; var _ = f[int]`, `f[int]`, `func(int)`}, {`package p2; func f[T any](T) {}; func _() { f(42) }`, `f`, `func(int)`}, {`package p3; func f[T any](T) {}; func _() { f[int](42) }`, `f[int]`, `func(int)`}, {`package p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T any](T)`}, {`package p5; func f[T any](T) {}; func _() { f(42) }`, `f(42)`, `()`}, // type parameters {`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t {`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P any]`}, {`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P interface{}]`}, {`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P, Q interface{}]`}, {brokenPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P, Q interface{m()}]`}, // instantiated types must be sanitized {`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`}, // go.dev/issue/45096 {`package issue45096; func _[T interface{ ~int8 | ~int16 | ~int32 }](x T) { _ = x < 0 }`, `0`, `T`}, // go.dev/issue/47895 {`package p; import "unsafe"; type S struct { f int }; var s S; var _ = unsafe.Offsetof(s.f)`, `s.f`, `int`}, // go.dev/issue/50093 {`package u0a; func _[_ interface{int}]() {}`, `int`, `int`}, {`package u1a; func _[_ interface{~int}]() {}`, `~int`, `~int`}, {`package u2a; func _[_ interface{int | string}]() {}`, `int | string`, `int | string`}, {`package u3a; func _[_ interface{int | string | ~bool}]() {}`, `int | string | ~bool`, `int | string | ~bool`}, {`package u3a; func _[_ interface{int | string | ~bool}]() {}`, `int | string`, `int | string`}, {`package u3a; func _[_ interface{int | string | ~bool}]() {}`, `~bool`, `~bool`}, {`package u3a; func _[_ interface{int | string | ~float64|~bool}]() {}`, `int | string | ~float64`, `int | string | ~float64`}, {`package u0b; func _[_ int]() {}`, `int`, `int`}, {`package u1b; func _[_ ~int]() {}`, `~int`, `~int`}, {`package u2b; func _[_ int | string]() {}`, `int | string`, `int | string`}, {`package u3b; func _[_ int | string | ~bool]() {}`, `int | string | ~bool`, `int | string | ~bool`}, {`package u3b; func _[_ int | string | ~bool]() {}`, `int | string`, `int | string`}, {`package u3b; func _[_ int | string | ~bool]() {}`, `~bool`, `~bool`}, {`package u3b; func _[_ int | string | ~float64|~bool]() {}`, `int | string | ~float64`, `int | string | ~float64`}, {`package u0c; type _ interface{int}`, `int`, `int`}, {`package u1c; type _ interface{~int}`, `~int`, `~int`}, {`package u2c; type _ interface{int | string}`, `int | string`, `int | string`}, {`package u3c; type _ interface{int | string | ~bool}`, `int | string | ~bool`, `int | string | ~bool`}, {`package u3c; type _ interface{int | string | ~bool}`, `int | string`, `int | string`}, {`package u3c; type _ interface{int | string | ~bool}`, `~bool`, `~bool`}, {`package u3c; type _ interface{int | string | ~float64|~bool}`, `int | string | ~float64`, `int | string | ~float64`}, // reverse type inference {`package r1; var _ func(int) = g; func g[P any](P) {}`, `g`, `func(int)`}, {`package r2; var _ func(int) = g[int]; func g[P any](P) {}`, `g`, `func[P any](P)`}, // go.dev/issues/60212 {`package r3; var _ func(int) = g[int]; func g[P any](P) {}`, `g[int]`, `func(int)`}, {`package r4; var _ func(int, string) = g; func g[P, Q any](P, Q) {}`, `g`, `func(int, string)`}, {`package r5; var _ func(int, string) = g[int]; func g[P, Q any](P, Q) {}`, `g`, `func[P, Q any](P, Q)`}, // go.dev/issues/60212 {`package r6; var _ func(int, string) = g[int]; func g[P, Q any](P, Q) {}`, `g[int]`, `func(int, string)`}, {`package s1; func _() { f(g) }; func f(func(int)) {}; func g[P any](P) {}`, `g`, `func(int)`}, {`package s2; func _() { f(g[int]) }; func f(func(int)) {}; func g[P any](P) {}`, `g`, `func[P any](P)`}, // go.dev/issues/60212 {`package s3; func _() { f(g[int]) }; func f(func(int)) {}; func g[P any](P) {}`, `g[int]`, `func(int)`}, {`package s4; func _() { f(g) }; func f(func(int, string)) {}; func g[P, Q any](P, Q) {}`, `g`, `func(int, string)`}, {`package s5; func _() { f(g[int]) }; func f(func(int, string)) {}; func g[P, Q any](P, Q) {}`, `g`, `func[P, Q any](P, Q)`}, // go.dev/issues/60212 {`package s6; func _() { f(g[int]) }; func f(func(int, string)) {}; func g[P, Q any](P, Q) {}`, `g[int]`, `func(int, string)`}, {`package s7; func _() { f(g, h) }; func f[P any](func(int, P), func(P, string)) {}; func g[P any](P, P) {}; func h[P, Q any](P, Q) {}`, `g`, `func(int, int)`}, {`package s8; func _() { f(g, h) }; func f[P any](func(int, P), func(P, string)) {}; func g[P any](P, P) {}; func h[P, Q any](P, Q) {}`, `h`, `func(int, string)`}, {`package s9; func _() { f(g, h[int]) }; func f[P any](func(int, P), func(P, string)) {}; func g[P any](P, P) {}; func h[P, Q any](P, Q) {}`, `h`, `func[P, Q any](P, Q)`}, // go.dev/issues/60212 {`package s10; func _() { f(g, h[int]) }; func f[P any](func(int, P), func(P, string)) {}; func g[P any](P, P) {}; func h[P, Q any](P, Q) {}`, `h[int]`, `func(int, string)`}, } for _, test := range tests { info := Info{Types: make(map[syntax.Expr]TypeAndValue)} var name string if strings.HasPrefix(test.src, brokenPkg) { pkg, err := typecheck(test.src, nil, &info) if err == nil { t.Errorf("package %s: expected to fail but passed", pkg.Name()) continue } if pkg != nil { name = pkg.Name() } } else { name = mustTypecheck(test.src, nil, &info).Name() } // look for expression type var typ Type for e, tv := range info.Types { if syntax.String(e) == test.expr { typ = tv.Type break } } if typ == nil { t.Errorf("package %s: no type found for %s", name, test.expr) continue } // check that type is correct if got := typ.String(); got != test.typ { t.Errorf("package %s: expr = %s: got %s; want %s", name, test.expr, got, test.typ) } } } func TestInstanceInfo(t *testing.T) { const lib = `package lib func F[P any](P) {} type T[P any] []P ` type testInst struct { name string targs []string typ string } var tests = []struct { src string instances []testInst // recorded instances in source order }{ {`package p0; func f[T any](T) {}; func _() { f(42) }`, []testInst{{`f`, []string{`int`}, `func(int)`}}, }, {`package p1; func f[T any](T) T { panic(0) }; func _() { f('@') }`, []testInst{{`f`, []string{`rune`}, `func(rune) rune`}}, }, {`package p2; func f[T any](...T) T { panic(0) }; func _() { f(0i) }`, []testInst{{`f`, []string{`complex128`}, `func(...complex128) complex128`}}, }, {`package p3; func f[A, B, C any](A, *B, []C) {}; func _() { f(1.2, new(string), []byte{}) }`, []testInst{{`f`, []string{`float64`, `string`, `byte`}, `func(float64, *string, []byte)`}}, }, {`package p4; func f[A, B any](A, *B, ...[]B) {}; func _() { f(1.2, new(byte)) }`, []testInst{{`f`, []string{`float64`, `byte`}, `func(float64, *byte, ...[]byte)`}}, }, {`package s1; func f[T any, P interface{*T}](x T) {}; func _(x string) { f(x) }`, []testInst{{`f`, []string{`string`, `*string`}, `func(x string)`}}, }, {`package s2; func f[T any, P interface{*T}](x []T) {}; func _(x []int) { f(x) }`, []testInst{{`f`, []string{`int`, `*int`}, `func(x []int)`}}, }, {`package s3; type C[T any] interface{chan<- T}; func f[T any, P C[T]](x []T) {}; func _(x []int) { f(x) }`, []testInst{ {`C`, []string{`T`}, `interface{chan<- T}`}, {`f`, []string{`int`, `chan<- int`}, `func(x []int)`}, }, }, {`package s4; type C[T any] interface{chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T) {}; func _(x []int) { f(x) }`, []testInst{ {`C`, []string{`T`}, `interface{chan<- T}`}, {`C`, []string{`[]*P`}, `interface{chan<- []*P}`}, {`f`, []string{`int`, `chan<- int`, `chan<- []*chan<- int`}, `func(x []int)`}, }, }, {`package t1; func f[T any, P interface{*T}]() T { panic(0) }; func _() { _ = f[string] }`, []testInst{{`f`, []string{`string`, `*string`}, `func() string`}}, }, {`package t2; func f[T any, P interface{*T}]() T { panic(0) }; func _() { _ = (f[string]) }`, []testInst{{`f`, []string{`string`, `*string`}, `func() string`}}, }, {`package t3; type C[T any] interface{chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T { return nil }; func _() { _ = f[int] }`, []testInst{ {`C`, []string{`T`}, `interface{chan<- T}`}, {`C`, []string{`[]*P`}, `interface{chan<- []*P}`}, {`f`, []string{`int`, `chan<- int`, `chan<- []*chan<- int`}, `func() []int`}, }, }, {`package t4; type C[T any] interface{chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T { return nil }; func _() { _ = (f[int]) }`, []testInst{ {`C`, []string{`T`}, `interface{chan<- T}`}, {`C`, []string{`[]*P`}, `interface{chan<- []*P}`}, {`f`, []string{`int`, `chan<- int`, `chan<- []*chan<- int`}, `func() []int`}, }, }, {`package i0; import "lib"; func _() { lib.F(42) }`, []testInst{{`F`, []string{`int`}, `func(int)`}}, }, {`package duplfunc0; func f[T any](T) {}; func _() { f(42); f("foo"); f[int](3) }`, []testInst{ {`f`, []string{`int`}, `func(int)`}, {`f`, []string{`string`}, `func(string)`}, {`f`, []string{`int`}, `func(int)`}, }, }, {`package duplfunc1; import "lib"; func _() { lib.F(42); lib.F("foo"); lib.F(3) }`, []testInst{ {`F`, []string{`int`}, `func(int)`}, {`F`, []string{`string`}, `func(string)`}, {`F`, []string{`int`}, `func(int)`}, }, }, {`package type0; type T[P interface{~int}] struct{ x P }; var _ T[int]`, []testInst{{`T`, []string{`int`}, `struct{x int}`}}, }, {`package type1; type T[P interface{~int}] struct{ x P }; var _ (T[int])`, []testInst{{`T`, []string{`int`}, `struct{x int}`}}, }, {`package type2; type T[P interface{~int}] struct{ x P }; var _ T[(int)]`, []testInst{{`T`, []string{`int`}, `struct{x int}`}}, }, {`package type3; type T[P1 interface{~[]P2}, P2 any] struct{ x P1; y P2 }; var _ T[[]int, int]`, []testInst{{`T`, []string{`[]int`, `int`}, `struct{x []int; y int}`}}, }, {`package type4; import "lib"; var _ lib.T[int]`, []testInst{{`T`, []string{`int`}, `[]int`}}, }, {`package dupltype0; type T[P interface{~int}] struct{ x P }; var x T[int]; var y T[int]`, []testInst{ {`T`, []string{`int`}, `struct{x int}`}, {`T`, []string{`int`}, `struct{x int}`}, }, }, {`package dupltype1; type T[P ~int] struct{ x P }; func (r *T[Q]) add(z T[Q]) { r.x += z.x }`, []testInst{ {`T`, []string{`Q`}, `struct{x Q}`}, {`T`, []string{`Q`}, `struct{x Q}`}, }, }, {`package dupltype1; import "lib"; var x lib.T[int]; var y lib.T[int]; var z lib.T[string]`, []testInst{ {`T`, []string{`int`}, `[]int`}, {`T`, []string{`int`}, `[]int`}, {`T`, []string{`string`}, `[]string`}, }, }, {`package issue51803; func foo[T any](T) {}; func _() { foo[int]( /* leave arg away on purpose */ ) }`, []testInst{{`foo`, []string{`int`}, `func(int)`}}, }, // reverse type inference {`package reverse1a; var f func(int) = g; func g[P any](P) {}`, []testInst{{`g`, []string{`int`}, `func(int)`}}, }, {`package reverse1b; func f(func(int)) {}; func g[P any](P) {}; func _() { f(g) }`, []testInst{{`g`, []string{`int`}, `func(int)`}}, }, {`package reverse2a; var f func(int, string) = g; func g[P, Q any](P, Q) {}`, []testInst{{`g`, []string{`int`, `string`}, `func(int, string)`}}, }, {`package reverse2b; func f(func(int, string)) {}; func g[P, Q any](P, Q) {}; func _() { f(g) }`, []testInst{{`g`, []string{`int`, `string`}, `func(int, string)`}}, }, {`package reverse2c; func f(func(int, string)) {}; func g[P, Q any](P, Q) {}; func _() { f(g[int]) }`, []testInst{{`g`, []string{`int`, `string`}, `func(int, string)`}}, }, // reverse3a not possible (cannot assign to generic function outside of argument passing) {`package reverse3b; func f[R any](func(int) R) {}; func g[P any](P) string { return "" }; func _() { f(g) }`, []testInst{ {`f`, []string{`string`}, `func(func(int) string)`}, {`g`, []string{`int`}, `func(int) string`}, }, }, {`package reverse4a; var _, _ func([]int, *float32) = g, h; func g[P, Q any]([]P, *Q) {}; func h[R any]([]R, *float32) {}`, []testInst{ {`g`, []string{`int`, `float32`}, `func([]int, *float32)`}, {`h`, []string{`int`}, `func([]int, *float32)`}, }, }, {`package reverse4b; func f(_, _ func([]int, *float32)) {}; func g[P, Q any]([]P, *Q) {}; func h[R any]([]R, *float32) {}; func _() { f(g, h) }`, []testInst{ {`g`, []string{`int`, `float32`}, `func([]int, *float32)`}, {`h`, []string{`int`}, `func([]int, *float32)`}, }, }, {`package issue59956; func f(func(int), func(string), func(bool)) {}; func g[P any](P) {}; func _() { f(g, g, g) }`, []testInst{ {`g`, []string{`int`}, `func(int)`}, {`g`, []string{`string`}, `func(string)`}, {`g`, []string{`bool`}, `func(bool)`}, }, }, } for _, test := range tests { imports := make(testImporter) conf := Config{Importer: imports} instMap := make(map[*syntax.Name]Instance) useMap := make(map[*syntax.Name]Object) makePkg := func(src string) *Package { pkg, err := typecheck(src, &conf, &Info{Instances: instMap, Uses: useMap}) // allow error for issue51803 if err != nil && (pkg == nil || pkg.Name() != "issue51803") { t.Fatal(err) } imports[pkg.Name()] = pkg return pkg } makePkg(lib) pkg := makePkg(test.src) t.Run(pkg.Name(), func(t *testing.T) { // Sort instances in source order for stability. instances := sortedInstances(instMap) if got, want := len(instances), len(test.instances); got != want { t.Fatalf("got %d instances, want %d", got, want) } // Pairwise compare with the expected instances. for ii, inst := range instances { var targs []Type for i := 0; i < inst.Inst.TypeArgs.Len(); i++ { targs = append(targs, inst.Inst.TypeArgs.At(i)) } typ := inst.Inst.Type testInst := test.instances[ii] if got := inst.Name.Value; got != testInst.name { t.Fatalf("got name %s, want %s", got, testInst.name) } if len(targs) != len(testInst.targs) { t.Fatalf("got %d type arguments; want %d", len(targs), len(testInst.targs)) } for i, targ := range targs { if got := targ.String(); got != testInst.targs[i] { t.Errorf("type argument %d: got %s; want %s", i, got, testInst.targs[i]) } } if got := typ.Underlying().String(); got != testInst.typ { t.Errorf("package %s: got %s; want %s", pkg.Name(), got, testInst.typ) } // Verify the invariant that re-instantiating the corresponding generic // type with TypeArgs results in an identical instance. ptype := useMap[inst.Name].Type() lister, _ := ptype.(interface{ TypeParams() *TypeParamList }) if lister == nil || lister.TypeParams().Len() == 0 { t.Fatalf("info.Types[%v] = %v, want parameterized type", inst.Name, ptype) } inst2, err := Instantiate(nil, ptype, targs, true) if err != nil { t.Errorf("Instantiate(%v, %v) failed: %v", ptype, targs, err) } if !Identical(inst.Inst.Type, inst2) { t.Errorf("%v and %v are not identical", inst.Inst.Type, inst2) } } }) } } type recordedInstance struct { Name *syntax.Name Inst Instance } func sortedInstances(m map[*syntax.Name]Instance) (instances []recordedInstance) { for id, inst := range m { instances = append(instances, recordedInstance{id, inst}) } sort.Slice(instances, func(i, j int) bool { return CmpPos(instances[i].Name.Pos(), instances[j].Name.Pos()) < 0 }) return instances } func TestDefsInfo(t *testing.T) { var tests = []struct { src string obj string want string }{ {`package p0; const x = 42`, `x`, `const p0.x untyped int`}, {`package p1; const x int = 42`, `x`, `const p1.x int`}, {`package p2; var x int`, `x`, `var p2.x int`}, {`package p3; type x int`, `x`, `type p3.x int`}, {`package p4; func f()`, `f`, `func p4.f()`}, {`package p5; func f() int { x, _ := 1, 2; return x }`, `_`, `var _ int`}, // Tests using generics. {`package g0; type x[T any] int`, `x`, `type g0.x[T any] int`}, {`package g1; func f[T any]() {}`, `f`, `func g1.f[T any]()`}, {`package g2; type x[T any] int; func (*x[_]) m() {}`, `m`, `func (*g2.x[_]).m()`}, } for _, test := range tests { info := Info{ Defs: make(map[*syntax.Name]Object), } name := mustTypecheck(test.src, nil, &info).Name() // find object var def Object for id, obj := range info.Defs { if id.Value == test.obj { def = obj break } } if def == nil { t.Errorf("package %s: %s not found", name, test.obj) continue } if got := def.String(); got != test.want { t.Errorf("package %s: got %s; want %s", name, got, test.want) } } } func TestUsesInfo(t *testing.T) { var tests = []struct { src string obj string want string }{ {`package p0; func _() { _ = x }; const x = 42`, `x`, `const p0.x untyped int`}, {`package p1; func _() { _ = x }; const x int = 42`, `x`, `const p1.x int`}, {`package p2; func _() { _ = x }; var x int`, `x`, `var p2.x int`}, {`package p3; func _() { type _ x }; type x int`, `x`, `type p3.x int`}, {`package p4; func _() { _ = f }; func f()`, `f`, `func p4.f()`}, // Tests using generics. {`package g0; func _[T any]() { _ = x }; const x = 42`, `x`, `const g0.x untyped int`}, {`package g1; func _[T any](x T) { }`, `T`, `type parameter T any`}, {`package g2; type N[A any] int; var _ N[int]`, `N`, `type g2.N[A any] int`}, {`package g3; type N[A any] int; func (N[_]) m() {}`, `N`, `type g3.N[A any] int`}, // Uses of fields are instantiated. {`package s1; type N[A any] struct{ a A }; var f = N[int]{}.a`, `a`, `field a int`}, {`package s1; type N[A any] struct{ a A }; func (r N[B]) m(b B) { r.a = b }`, `a`, `field a B`}, // Uses of methods are uses of the instantiated method. {`package m0; type N[A any] int; func (r N[B]) m() { r.n() }; func (N[C]) n() {}`, `n`, `func (m0.N[B]).n()`}, {`package m1; type N[A any] int; func (r N[B]) m() { }; var f = N[int].m`, `m`, `func (m1.N[int]).m()`}, {`package m2; func _[A any](v interface{ m() A }) { v.m() }`, `m`, `func (interface).m() A`}, {`package m3; func f[A any]() interface{ m() A } { return nil }; var _ = f[int]().m()`, `m`, `func (interface).m() int`}, {`package m4; type T[A any] func() interface{ m() A }; var x T[int]; var y = x().m`, `m`, `func (interface).m() int`}, {`package m5; type T[A any] interface{ m() A }; func _[B any](t T[B]) { t.m() }`, `m`, `func (m5.T[B]).m() B`}, {`package m6; type T[A any] interface{ m() }; func _[B any](t T[B]) { t.m() }`, `m`, `func (m6.T[B]).m()`}, {`package m7; type T[A any] interface{ m() A }; func _(t T[int]) { t.m() }`, `m`, `func (m7.T[int]).m() int`}, {`package m8; type T[A any] interface{ m() }; func _(t T[int]) { t.m() }`, `m`, `func (m8.T[int]).m()`}, {`package m9; type T[A any] interface{ m() }; func _(t T[int]) { _ = t.m }`, `m`, `func (m9.T[int]).m()`}, { `package m10; type E[A any] interface{ m() }; type T[B any] interface{ E[B]; n() }; func _(t T[int]) { t.m() }`, `m`, `func (m10.E[int]).m()`, }, } for _, test := range tests { info := Info{ Uses: make(map[*syntax.Name]Object), } name := mustTypecheck(test.src, nil, &info).Name() // find object var use Object for id, obj := range info.Uses { if id.Value == test.obj { if use != nil { panic(fmt.Sprintf("multiple uses of %q", id.Value)) } use = obj } } if use == nil { t.Errorf("package %s: %s not found", name, test.obj) continue } if got := use.String(); got != test.want { t.Errorf("package %s: got %s; want %s", name, got, test.want) } } } func TestGenericMethodInfo(t *testing.T) { src := `package p type N[A any] int func (r N[B]) m() { r.m(); r.n() } func (r *N[C]) n() { } ` f := mustParse(src) info := Info{ Defs: make(map[*syntax.Name]Object), Uses: make(map[*syntax.Name]Object), Selections: make(map[*syntax.SelectorExpr]*Selection), } var conf Config pkg, err := conf.Check("p", []*syntax.File{f}, &info) if err != nil { t.Fatal(err) } N := pkg.Scope().Lookup("N").Type().(*Named) // Find the generic methods stored on N. gm, gn := N.Method(0), N.Method(1) if gm.Name() == "n" { gm, gn = gn, gm } // Collect objects from info. var dm, dn *Func // the declared methods var dmm, dmn *Func // the methods used in the body of m for _, decl := range f.DeclList { fdecl, ok := decl.(*syntax.FuncDecl) if !ok { continue } def := info.Defs[fdecl.Name].(*Func) switch fdecl.Name.Value { case "m": dm = def syntax.Inspect(fdecl.Body, func(n syntax.Node) bool { if call, ok := n.(*syntax.CallExpr); ok { sel := call.Fun.(*syntax.SelectorExpr) use := info.Uses[sel.Sel].(*Func) selection := info.Selections[sel] if selection.Kind() != MethodVal { t.Errorf("Selection kind = %v, want %v", selection.Kind(), MethodVal) } if selection.Obj() != use { t.Errorf("info.Selections contains %v, want %v", selection.Obj(), use) } switch sel.Sel.Value { case "m": dmm = use case "n": dmn = use } } return true }) case "n": dn = def } } if gm != dm { t.Errorf(`N.Method(...) returns %v for "m", but Info.Defs has %v`, gm, dm) } if gn != dn { t.Errorf(`N.Method(...) returns %v for "m", but Info.Defs has %v`, gm, dm) } if dmm != dm { t.Errorf(`Inside "m", r.m uses %v, want the defined func %v`, dmm, dm) } if dmn == dn { t.Errorf(`Inside "m", r.n uses %v, want a func distinct from %v`, dmm, dm) } } func TestImplicitsInfo(t *testing.T) { testenv.MustHaveGoBuild(t) var tests = []struct { src string want string }{ {`package p2; import . "fmt"; var _ = Println`, ""}, // no Implicits entry {`package p0; import local "fmt"; var _ = local.Println`, ""}, // no Implicits entry {`package p1; import "fmt"; var _ = fmt.Println`, "importSpec: package fmt"}, {`package p3; func f(x interface{}) { switch x.(type) { case int: } }`, ""}, // no Implicits entry {`package p4; func f(x interface{}) { switch t := x.(type) { case int: _ = t } }`, "caseClause: var t int"}, {`package p5; func f(x interface{}) { switch t := x.(type) { case int, uint: _ = t } }`, "caseClause: var t interface{}"}, {`package p6; func f(x interface{}) { switch t := x.(type) { default: _ = t } }`, "caseClause: var t interface{}"}, {`package p7; func f(x int) {}`, ""}, // no Implicits entry {`package p8; func f(int) {}`, "field: var int"}, {`package p9; func f() (complex64) { return 0 }`, "field: var complex64"}, {`package p10; type T struct{}; func (*T) f() {}`, "field: var *p10.T"}, // Tests using generics. {`package f0; func f[T any](x int) {}`, ""}, // no Implicits entry {`package f1; func f[T any](int) {}`, "field: var int"}, {`package f2; func f[T any](T) {}`, "field: var T"}, {`package f3; func f[T any]() (complex64) { return 0 }`, "field: var complex64"}, {`package f4; func f[T any](t T) (T) { return t }`, "field: var T"}, {`package t0; type T[A any] struct{}; func (*T[_]) f() {}`, "field: var *t0.T[_]"}, {`package t1; type T[A any] struct{}; func _(x interface{}) { switch t := x.(type) { case T[int]: _ = t } }`, "caseClause: var t t1.T[int]"}, {`package t2; type T[A any] struct{}; func _[P any](x interface{}) { switch t := x.(type) { case T[P]: _ = t } }`, "caseClause: var t t2.T[P]"}, {`package t3; func _[P any](x interface{}) { switch t := x.(type) { case P: _ = t } }`, "caseClause: var t P"}, } for _, test := range tests { info := Info{ Implicits: make(map[syntax.Node]Object), } name := mustTypecheck(test.src, nil, &info).Name() // the test cases expect at most one Implicits entry if len(info.Implicits) > 1 { t.Errorf("package %s: %d Implicits entries found", name, len(info.Implicits)) continue } // extract Implicits entry, if any var got string for n, obj := range info.Implicits { switch x := n.(type) { case *syntax.ImportDecl: got = "importSpec" case *syntax.CaseClause: got = "caseClause" case *syntax.Field: got = "field" default: t.Fatalf("package %s: unexpected %T", name, x) } got += ": " + obj.String() } // verify entry if got != test.want { t.Errorf("package %s: got %q; want %q", name, got, test.want) } } } func TestPkgNameOf(t *testing.T) { testenv.MustHaveGoBuild(t) const src = ` package p import ( . "os" _ "io" "math" "path/filepath" snort "sort" ) // avoid imported and not used errors var ( _ = Open // os.Open _ = math.Sin _ = filepath.Abs _ = snort.Ints ) ` var tests = []struct { path string // path string enclosed in "'s want string }{ {`"os"`, "."}, {`"io"`, "_"}, {`"math"`, "math"}, {`"path/filepath"`, "filepath"}, {`"sort"`, "snort"}, } f := mustParse(src) info := Info{ Defs: make(map[*syntax.Name]Object), Implicits: make(map[syntax.Node]Object), } var conf Config conf.Importer = defaultImporter() _, err := conf.Check("p", []*syntax.File{f}, &info) if err != nil { t.Fatal(err) } // map import paths to importDecl imports := make(map[string]*syntax.ImportDecl) for _, d := range f.DeclList { if imp, _ := d.(*syntax.ImportDecl); imp != nil { imports[imp.Path.Value] = imp } } for _, test := range tests { imp := imports[test.path] if imp == nil { t.Fatalf("invalid test case: import path %s not found", test.path) } got := info.PkgNameOf(imp) if got == nil { t.Fatalf("import %s: package name not found", test.path) } if got.Name() != test.want { t.Errorf("import %s: got %s; want %s", test.path, got.Name(), test.want) } } // test non-existing importDecl if got := info.PkgNameOf(new(syntax.ImportDecl)); got != nil { t.Errorf("got %s for non-existing import declaration", got.Name()) } } func predString(tv TypeAndValue) string { var buf strings.Builder pred := func(b bool, s string) { if b { if buf.Len() > 0 { buf.WriteString(", ") } buf.WriteString(s) } } pred(tv.IsVoid(), "void") pred(tv.IsType(), "type") pred(tv.IsBuiltin(), "builtin") pred(tv.IsValue() && tv.Value != nil, "const") pred(tv.IsValue() && tv.Value == nil, "value") pred(tv.IsNil(), "nil") pred(tv.Addressable(), "addressable") pred(tv.Assignable(), "assignable") pred(tv.HasOk(), "hasOk") if buf.Len() == 0 { return "invalid" } return buf.String() } func TestPredicatesInfo(t *testing.T) { testenv.MustHaveGoBuild(t) var tests = []struct { src string expr string pred string }{ // void {`package n0; func f() { f() }`, `f()`, `void`}, // types {`package t0; type _ int`, `int`, `type`}, {`package t1; type _ []int`, `[]int`, `type`}, {`package t2; type _ func()`, `func()`, `type`}, {`package t3; type _ func(int)`, `int`, `type`}, {`package t3; type _ func(...int)`, `...int`, `type`}, // built-ins {`package b0; var _ = len("")`, `len`, `builtin`}, {`package b1; var _ = (len)("")`, `(len)`, `builtin`}, // constants {`package c0; var _ = 42`, `42`, `const`}, {`package c1; var _ = "foo" + "bar"`, `"foo" + "bar"`, `const`}, {`package c2; const (i = 1i; _ = i)`, `i`, `const`}, // values {`package v0; var (a, b int; _ = a + b)`, `a + b`, `value`}, {`package v1; var _ = &[]int{1}`, `[]int{…}`, `value`}, {`package v2; var _ = func(){}`, `func() {}`, `value`}, {`package v4; func f() { _ = f }`, `f`, `value`}, {`package v3; var _ *int = nil`, `nil`, `value, nil`}, {`package v3; var _ *int = (nil)`, `(nil)`, `value, nil`}, // addressable (and thus assignable) operands {`package a0; var (x int; _ = x)`, `x`, `value, addressable, assignable`}, {`package a1; var (p *int; _ = *p)`, `*p`, `value, addressable, assignable`}, {`package a2; var (s []int; _ = s[0])`, `s[0]`, `value, addressable, assignable`}, {`package a3; var (s struct{f int}; _ = s.f)`, `s.f`, `value, addressable, assignable`}, {`package a4; var (a [10]int; _ = a[0])`, `a[0]`, `value, addressable, assignable`}, {`package a5; func _(x int) { _ = x }`, `x`, `value, addressable, assignable`}, {`package a6; func _()(x int) { _ = x; return }`, `x`, `value, addressable, assignable`}, {`package a7; type T int; func (x T) _() { _ = x }`, `x`, `value, addressable, assignable`}, // composite literals are not addressable // assignable but not addressable values {`package s0; var (m map[int]int; _ = m[0])`, `m[0]`, `value, assignable, hasOk`}, {`package s1; var (m map[int]int; _, _ = m[0])`, `m[0]`, `value, assignable, hasOk`}, // hasOk expressions {`package k0; var (ch chan int; _ = <-ch)`, `<-ch`, `value, hasOk`}, {`package k1; var (ch chan int; _, _ = <-ch)`, `<-ch`, `value, hasOk`}, // missing entries // - package names are collected in the Uses map // - identifiers being declared are collected in the Defs map {`package m0; import "os"; func _() { _ = os.Stdout }`, `os`, `<missing>`}, {`package m1; import p "os"; func _() { _ = p.Stdout }`, `p`, `<missing>`}, {`package m2; const c = 0`, `c`, `<missing>`}, {`package m3; type T int`, `T`, `<missing>`}, {`package m4; var v int`, `v`, `<missing>`}, {`package m5; func f() {}`, `f`, `<missing>`}, {`package m6; func _(x int) {}`, `x`, `<missing>`}, {`package m6; func _()(x int) { return }`, `x`, `<missing>`}, {`package m6; type T int; func (x T) _() {}`, `x`, `<missing>`}, } for _, test := range tests { info := Info{Types: make(map[syntax.Expr]TypeAndValue)} name := mustTypecheck(test.src, nil, &info).Name() // look for expression predicates got := "<missing>" for e, tv := range info.Types { //println(name, syntax.String(e)) if syntax.String(e) == test.expr { got = predString(tv) break } } if got != test.pred { t.Errorf("package %s: got %s; want %s", name, got, test.pred) } } } func TestScopesInfo(t *testing.T) { testenv.MustHaveGoBuild(t) var tests = []struct { src string scopes []string // list of scope descriptors of the form kind:varlist }{ {`package p0`, []string{ "file:", }}, {`package p1; import ( "fmt"; m "math"; _ "os" ); var ( _ = fmt.Println; _ = m.Pi )`, []string{ "file:fmt m", }}, {`package p2; func _() {}`, []string{ "file:", "func:", }}, {`package p3; func _(x, y int) {}`, []string{ "file:", "func:x y", }}, {`package p4; func _(x, y int) { x, z := 1, 2; _ = z }`, []string{ "file:", "func:x y z", // redeclaration of x }}, {`package p5; func _(x, y int) (u, _ int) { return }`, []string{ "file:", "func:u x y", }}, {`package p6; func _() { { var x int; _ = x } }`, []string{ "file:", "func:", "block:x", }}, {`package p7; func _() { if true {} }`, []string{ "file:", "func:", "if:", "block:", }}, {`package p8; func _() { if x := 0; x < 0 { y := x; _ = y } }`, []string{ "file:", "func:", "if:x", "block:y", }}, {`package p9; func _() { switch x := 0; x {} }`, []string{ "file:", "func:", "switch:x", }}, {`package p10; func _() { switch x := 0; x { case 1: y := x; _ = y; default: }}`, []string{ "file:", "func:", "switch:x", "case:y", "case:", }}, {`package p11; func _(t interface{}) { switch t.(type) {} }`, []string{ "file:", "func:t", "switch:", }}, {`package p12; func _(t interface{}) { switch t := t; t.(type) {} }`, []string{ "file:", "func:t", "switch:t", }}, {`package p13; func _(t interface{}) { switch x := t.(type) { case int: _ = x } }`, []string{ "file:", "func:t", "switch:", "case:x", // x implicitly declared }}, {`package p14; func _() { select{} }`, []string{ "file:", "func:", }}, {`package p15; func _(c chan int) { select{ case <-c: } }`, []string{ "file:", "func:c", "comm:", }}, {`package p16; func _(c chan int) { select{ case i := <-c: x := i; _ = x} }`, []string{ "file:", "func:c", "comm:i x", }}, {`package p17; func _() { for{} }`, []string{ "file:", "func:", "for:", "block:", }}, {`package p18; func _(n int) { for i := 0; i < n; i++ { _ = i } }`, []string{ "file:", "func:n", "for:i", "block:", }}, {`package p19; func _(a []int) { for i := range a { _ = i} }`, []string{ "file:", "func:a", "for:i", "block:", }}, {`package p20; var s int; func _(a []int) { for i, x := range a { s += x; _ = i } }`, []string{ "file:", "func:a", "for:i x", "block:", }}, } for _, test := range tests { info := Info{Scopes: make(map[syntax.Node]*Scope)} name := mustTypecheck(test.src, nil, &info).Name() // number of scopes must match if len(info.Scopes) != len(test.scopes) { t.Errorf("package %s: got %d scopes; want %d", name, len(info.Scopes), len(test.scopes)) } // scope descriptions must match for node, scope := range info.Scopes { var kind string switch node.(type) { case *syntax.File: kind = "file" case *syntax.FuncType: kind = "func" case *syntax.BlockStmt: kind = "block" case *syntax.IfStmt: kind = "if" case *syntax.SwitchStmt: kind = "switch" case *syntax.SelectStmt: kind = "select" case *syntax.CaseClause: kind = "case" case *syntax.CommClause: kind = "comm" case *syntax.ForStmt: kind = "for" default: kind = fmt.Sprintf("%T", node) } // look for matching scope description desc := kind + ":" + strings.Join(scope.Names(), " ") found := false for _, d := range test.scopes { if desc == d { found = true break } } if !found { t.Errorf("package %s: no matching scope found for %s", name, desc) } } } } func TestInitOrderInfo(t *testing.T) { var tests = []struct { src string inits []string }{ {`package p0; var (x = 1; y = x)`, []string{ "x = 1", "y = x", }}, {`package p1; var (a = 1; b = 2; c = 3)`, []string{ "a = 1", "b = 2", "c = 3", }}, {`package p2; var (a, b, c = 1, 2, 3)`, []string{ "a = 1", "b = 2", "c = 3", }}, {`package p3; var _ = f(); func f() int { return 1 }`, []string{ "_ = f()", // blank var }}, {`package p4; var (a = 0; x = y; y = z; z = 0)`, []string{ "a = 0", "z = 0", "y = z", "x = y", }}, {`package p5; var (a, _ = m[0]; m map[int]string)`, []string{ "a, _ = m[0]", // blank var }}, {`package p6; var a, b = f(); func f() (_, _ int) { return z, z }; var z = 0`, []string{ "z = 0", "a, b = f()", }}, {`package p7; var (a = func() int { return b }(); b = 1)`, []string{ "b = 1", "a = func() int {…}()", }}, {`package p8; var (a, b = func() (_, _ int) { return c, c }(); c = 1)`, []string{ "c = 1", "a, b = func() (_, _ int) {…}()", }}, {`package p9; type T struct{}; func (T) m() int { _ = y; return 0 }; var x, y = T.m, 1`, []string{ "y = 1", "x = T.m", }}, {`package p10; var (d = c + b; a = 0; b = 0; c = 0)`, []string{ "a = 0", "b = 0", "c = 0", "d = c + b", }}, {`package p11; var (a = e + c; b = d + c; c = 0; d = 0; e = 0)`, []string{ "c = 0", "d = 0", "b = d + c", "e = 0", "a = e + c", }}, // emit an initializer for n:1 initializations only once (not for each node // on the lhs which may appear in different order in the dependency graph) {`package p12; var (a = x; b = 0; x, y = m[0]; m map[int]int)`, []string{ "b = 0", "x, y = m[0]", "a = x", }}, // test case from spec section on package initialization {`package p12 var ( a = c + b b = f() c = f() d = 3 ) func f() int { d++ return d }`, []string{ "d = 3", "b = f()", "c = f()", "a = c + b", }}, // test case for go.dev/issue/7131 {`package main var counter int func next() int { counter++; return counter } var _ = makeOrder() func makeOrder() []int { return []int{f, b, d, e, c, a} } var a = next() var b, c = next(), next() var d, e, f = next(), next(), next() `, []string{ "a = next()", "b = next()", "c = next()", "d = next()", "e = next()", "f = next()", "_ = makeOrder()", }}, // test case for go.dev/issue/10709 {`package p13 var ( v = t.m() t = makeT(0) ) type T struct{} func (T) m() int { return 0 } func makeT(n int) T { if n > 0 { return makeT(n-1) } return T{} }`, []string{ "t = makeT(0)", "v = t.m()", }}, // test case for go.dev/issue/10709: same as test before, but variable decls swapped {`package p14 var ( t = makeT(0) v = t.m() ) type T struct{} func (T) m() int { return 0 } func makeT(n int) T { if n > 0 { return makeT(n-1) } return T{} }`, []string{ "t = makeT(0)", "v = t.m()", }}, // another candidate possibly causing problems with go.dev/issue/10709 {`package p15 var y1 = f1() func f1() int { return g1() } func g1() int { f1(); return x1 } var x1 = 0 var y2 = f2() func f2() int { return g2() } func g2() int { return x2 } var x2 = 0`, []string{ "x1 = 0", "y1 = f1()", "x2 = 0", "y2 = f2()", }}, } for _, test := range tests { info := Info{} name := mustTypecheck(test.src, nil, &info).Name() // number of initializers must match if len(info.InitOrder) != len(test.inits) { t.Errorf("package %s: got %d initializers; want %d", name, len(info.InitOrder), len(test.inits)) continue } // initializers must match for i, want := range test.inits { got := info.InitOrder[i].String() if got != want { t.Errorf("package %s, init %d: got %s; want %s", name, i, got, want) continue } } } } func TestMultiFileInitOrder(t *testing.T) { fileA := mustParse(`package main; var a = 1`) fileB := mustParse(`package main; var b = 2`) // The initialization order must not depend on the parse // order of the files, only on the presentation order to // the type-checker. for _, test := range []struct { files []*syntax.File want string }{ {[]*syntax.File{fileA, fileB}, "[a = 1 b = 2]"}, {[]*syntax.File{fileB, fileA}, "[b = 2 a = 1]"}, } { var info Info if _, err := new(Config).Check("main", test.files, &info); err != nil { t.Fatal(err) } if got := fmt.Sprint(info.InitOrder); got != test.want { t.Fatalf("got %s; want %s", got, test.want) } } } func TestFiles(t *testing.T) { var sources = []string{ "package p; type T struct{}; func (T) m1() {}", "package p; func (T) m2() {}; var x interface{ m1(); m2() } = T{}", "package p; func (T) m3() {}; var y interface{ m1(); m2(); m3() } = T{}", "package p", } var conf Config pkg := NewPackage("p", "p") var info Info check := NewChecker(&conf, pkg, &info) for _, src := range sources { if err := check.Files([]*syntax.File{mustParse(src)}); err != nil { t.Error(err) } } // check InitOrder is [x y] var vars []string for _, init := range info.InitOrder { for _, v := range init.Lhs { vars = append(vars, v.Name()) } } if got, want := fmt.Sprint(vars), "[x y]"; got != want { t.Errorf("InitOrder == %s, want %s", got, want) } } type testImporter map[string]*Package func (m testImporter) Import(path string) (*Package, error) { if pkg := m[path]; pkg != nil { return pkg, nil } return nil, fmt.Errorf("package %q not found", path) } func TestSelection(t *testing.T) { selections := make(map[*syntax.SelectorExpr]*Selection) imports := make(testImporter) conf := Config{Importer: imports} makePkg := func(path, src string) { pkg := mustTypecheck(src, &conf, &Info{Selections: selections}) imports[path] = pkg } const libSrc = ` package lib type T float64 const C T = 3 var V T func F() {} func (T) M() {} ` const mainSrc = ` package main import "lib" type A struct { *B C } type B struct { b int } func (B) f(int) type C struct { c int } type G[P any] struct { p P } func (G[P]) m(P) {} var Inst G[int] func (C) g() func (*C) h() func main() { // qualified identifiers var _ lib.T _ = lib.C _ = lib.F _ = lib.V _ = lib.T.M // fields _ = A{}.B _ = new(A).B _ = A{}.C _ = new(A).C _ = A{}.b _ = new(A).b _ = A{}.c _ = new(A).c _ = Inst.p _ = G[string]{}.p // methods _ = A{}.f _ = new(A).f _ = A{}.g _ = new(A).g _ = new(A).h _ = B{}.f _ = new(B).f _ = C{}.g _ = new(C).g _ = new(C).h _ = Inst.m // method expressions _ = A.f _ = (*A).f _ = B.f _ = (*B).f _ = G[string].m }` wantOut := map[string][2]string{ "lib.T.M": {"method expr (lib.T) M(lib.T)", ".[0]"}, "A{}.B": {"field (main.A) B *main.B", ".[0]"}, "new(A).B": {"field (*main.A) B *main.B", "->[0]"}, "A{}.C": {"field (main.A) C main.C", ".[1]"}, "new(A).C": {"field (*main.A) C main.C", "->[1]"}, "A{}.b": {"field (main.A) b int", "->[0 0]"}, "new(A).b": {"field (*main.A) b int", "->[0 0]"}, "A{}.c": {"field (main.A) c int", ".[1 0]"}, "new(A).c": {"field (*main.A) c int", "->[1 0]"}, "Inst.p": {"field (main.G[int]) p int", ".[0]"}, "A{}.f": {"method (main.A) f(int)", "->[0 0]"}, "new(A).f": {"method (*main.A) f(int)", "->[0 0]"}, "A{}.g": {"method (main.A) g()", ".[1 0]"}, "new(A).g": {"method (*main.A) g()", "->[1 0]"}, "new(A).h": {"method (*main.A) h()", "->[1 1]"}, // TODO(gri) should this report .[1 1] ? "B{}.f": {"method (main.B) f(int)", ".[0]"}, "new(B).f": {"method (*main.B) f(int)", "->[0]"}, "C{}.g": {"method (main.C) g()", ".[0]"}, "new(C).g": {"method (*main.C) g()", "->[0]"}, "new(C).h": {"method (*main.C) h()", "->[1]"}, // TODO(gri) should this report .[1] ? "Inst.m": {"method (main.G[int]) m(int)", ".[0]"}, "A.f": {"method expr (main.A) f(main.A, int)", "->[0 0]"}, "(*A).f": {"method expr (*main.A) f(*main.A, int)", "->[0 0]"}, "B.f": {"method expr (main.B) f(main.B, int)", ".[0]"}, "(*B).f": {"method expr (*main.B) f(*main.B, int)", "->[0]"}, "G[string].m": {"method expr (main.G[string]) m(main.G[string], string)", ".[0]"}, "G[string]{}.p": {"field (main.G[string]) p string", ".[0]"}, } makePkg("lib", libSrc) makePkg("main", mainSrc) for e, sel := range selections { _ = sel.String() // assertion: must not panic start := indexFor(mainSrc, syntax.StartPos(e)) end := indexFor(mainSrc, syntax.EndPos(e)) segment := mainSrc[start:end] // (all SelectorExprs are in main, not lib) direct := "." if sel.Indirect() { direct = "->" } got := [2]string{ sel.String(), fmt.Sprintf("%s%v", direct, sel.Index()), } want := wantOut[segment] if want != got { t.Errorf("%s: got %q; want %q", segment, got, want) } delete(wantOut, segment) // We must explicitly assert properties of the // Signature's receiver since it doesn't participate // in Identical() or String(). sig, _ := sel.Type().(*Signature) if sel.Kind() == MethodVal { got := sig.Recv().Type() want := sel.Recv() if !Identical(got, want) { t.Errorf("%s: Recv() = %s, want %s", segment, got, want) } } else if sig != nil && sig.Recv() != nil { t.Errorf("%s: signature has receiver %s", sig, sig.Recv().Type()) } } // Assert that all wantOut entries were used exactly once. for segment := range wantOut { t.Errorf("no syntax.Selection found with syntax %q", segment) } } // indexFor returns the index into s corresponding to the position pos. func indexFor(s string, pos syntax.Pos) int { i, line := 0, 1 // string index and corresponding line target := int(pos.Line()) for line < target && i < len(s) { if s[i] == '\n' { line++ } i++ } return i + int(pos.Col()-1) // columns are 1-based } func TestIssue8518(t *testing.T) { imports := make(testImporter) conf := Config{ Error: func(err error) { t.Log(err) }, // don't exit after first error Importer: imports, } makePkg := func(path, src string) { imports[path], _ = conf.Check(path, []*syntax.File{mustParse(src)}, nil) // errors logged via conf.Error } const libSrc = ` package a import "missing" const C1 = foo const C2 = missing.C ` const mainSrc = ` package main import "a" var _ = a.C1 var _ = a.C2 ` makePkg("a", libSrc) makePkg("main", mainSrc) // don't crash when type-checking this package } func TestIssue59603(t *testing.T) { imports := make(testImporter) conf := Config{ Error: func(err error) { t.Log(err) }, // don't exit after first error Importer: imports, } makePkg := func(path, src string) { imports[path], _ = conf.Check(path, []*syntax.File{mustParse(src)}, nil) // errors logged via conf.Error } const libSrc = ` package a const C = foo ` const mainSrc = ` package main import "a" const _ = a.C ` makePkg("a", libSrc) makePkg("main", mainSrc) // don't crash when type-checking this package } func TestLookupFieldOrMethodOnNil(t *testing.T) { // LookupFieldOrMethod on a nil type is expected to produce a run-time panic. defer func() { const want = "LookupFieldOrMethod on nil type" p := recover() if s, ok := p.(string); !ok || s != want { t.Fatalf("got %v, want %s", p, want) } }() LookupFieldOrMethod(nil, false, nil, "") } func TestLookupFieldOrMethod(t *testing.T) { // Test cases assume a lookup of the form a.f or x.f, where a stands for an // addressable value, and x for a non-addressable value (even though a variable // for ease of test case writing). var tests = []struct { src string found bool index []int indirect bool }{ // field lookups {"var x T; type T struct{}", false, nil, false}, {"var x T; type T struct{ f int }", true, []int{0}, false}, {"var x T; type T struct{ a, b, f, c int }", true, []int{2}, false}, // field lookups on a generic type {"var x T[int]; type T[P any] struct{}", false, nil, false}, {"var x T[int]; type T[P any] struct{ f P }", true, []int{0}, false}, {"var x T[int]; type T[P any] struct{ a, b, f, c P }", true, []int{2}, false}, // method lookups {"var a T; type T struct{}; func (T) f() {}", true, []int{0}, false}, {"var a *T; type T struct{}; func (T) f() {}", true, []int{0}, true}, {"var a T; type T struct{}; func (*T) f() {}", true, []int{0}, false}, {"var a *T; type T struct{}; func (*T) f() {}", true, []int{0}, true}, // TODO(gri) should this report indirect = false? // method lookups on a generic type {"var a T[int]; type T[P any] struct{}; func (T[P]) f() {}", true, []int{0}, false}, {"var a *T[int]; type T[P any] struct{}; func (T[P]) f() {}", true, []int{0}, true}, {"var a T[int]; type T[P any] struct{}; func (*T[P]) f() {}", true, []int{0}, false}, {"var a *T[int]; type T[P any] struct{}; func (*T[P]) f() {}", true, []int{0}, true}, // TODO(gri) should this report indirect = false? // collisions {"type ( E1 struct{ f int }; E2 struct{ f int }; x struct{ E1; *E2 })", false, []int{1, 0}, false}, {"type ( E1 struct{ f int }; E2 struct{}; x struct{ E1; *E2 }); func (E2) f() {}", false, []int{1, 0}, false}, // collisions on a generic type {"type ( E1[P any] struct{ f P }; E2[P any] struct{ f P }; x struct{ E1[int]; *E2[int] })", false, []int{1, 0}, false}, {"type ( E1[P any] struct{ f P }; E2[P any] struct{}; x struct{ E1[int]; *E2[int] }); func (E2[P]) f() {}", false, []int{1, 0}, false}, // outside methodset // (*T).f method exists, but value of type T is not addressable {"var x T; type T struct{}; func (*T) f() {}", false, nil, true}, // outside method set of a generic type {"var x T[int]; type T[P any] struct{}; func (*T[P]) f() {}", false, nil, true}, // recursive generic types; see go.dev/issue/52715 {"var a T[int]; type ( T[P any] struct { *N[P] }; N[P any] struct { *T[P] } ); func (N[P]) f() {}", true, []int{0, 0}, true}, {"var a T[int]; type ( T[P any] struct { *N[P] }; N[P any] struct { *T[P] } ); func (T[P]) f() {}", true, []int{0}, false}, } for _, test := range tests { pkg := mustTypecheck("package p;"+test.src, nil, nil) obj := pkg.Scope().Lookup("a") if obj == nil { if obj = pkg.Scope().Lookup("x"); obj == nil { t.Errorf("%s: incorrect test case - no object a or x", test.src) continue } } f, index, indirect := LookupFieldOrMethod(obj.Type(), obj.Name() == "a", pkg, "f") if (f != nil) != test.found { if f == nil { t.Errorf("%s: got no object; want one", test.src) } else { t.Errorf("%s: got object = %v; want none", test.src, f) } } if !sameSlice(index, test.index) { t.Errorf("%s: got index = %v; want %v", test.src, index, test.index) } if indirect != test.indirect { t.Errorf("%s: got indirect = %v; want %v", test.src, indirect, test.indirect) } } } // Test for go.dev/issue/52715 func TestLookupFieldOrMethod_RecursiveGeneric(t *testing.T) { const src = ` package pkg type Tree[T any] struct { *Node[T] } func (*Tree[R]) N(r R) R { return r } type Node[T any] struct { *Tree[T] } type Instance = *Tree[int] ` f := mustParse(src) pkg := NewPackage("pkg", f.PkgName.Value) if err := NewChecker(nil, pkg, nil).Files([]*syntax.File{f}); err != nil { panic(err) } T := pkg.Scope().Lookup("Instance").Type() _, _, _ = LookupFieldOrMethod(T, false, pkg, "M") // verify that LookupFieldOrMethod terminates } func sameSlice(a, b []int) bool { if len(a) != len(b) { return false } for i, x := range a { if x != b[i] { return false } } return true } // TestScopeLookupParent ensures that (*Scope).LookupParent returns // the correct result at various positions within the source. func TestScopeLookupParent(t *testing.T) { imports := make(testImporter) conf := Config{Importer: imports} var info Info makePkg := func(path, src string) { var err error imports[path], err = conf.Check(path, []*syntax.File{mustParse(src)}, &info) if err != nil { t.Fatal(err) } } makePkg("lib", "package lib; var X int") // Each /*name=kind:line*/ comment makes the test look up the // name at that point and checks that it resolves to a decl of // the specified kind and line number. "undef" means undefined. mainSrc := ` /*lib=pkgname:5*/ /*X=var:1*/ /*Pi=const:8*/ /*T=typename:9*/ /*Y=var:10*/ /*F=func:12*/ package main import "lib" import . "lib" const Pi = 3.1415 type T struct{} var Y, _ = lib.X, X func F[T *U, U any](param1, param2 int) /*param1=undef*/ (res1 /*res1=undef*/, res2 int) /*param1=var:12*/ /*res1=var:12*/ /*U=typename:12*/ { const pi, e = 3.1415, /*pi=undef*/ 2.71828 /*pi=const:13*/ /*e=const:13*/ type /*t=undef*/ t /*t=typename:14*/ *t print(Y) /*Y=var:10*/ x, Y := Y, /*x=undef*/ /*Y=var:10*/ Pi /*x=var:16*/ /*Y=var:16*/ ; _ = x; _ = Y var F = /*F=func:12*/ F[*int, int] /*F=var:17*/ ; _ = F var a []int for i, x := range a /*i=undef*/ /*x=var:16*/ { _ = i; _ = x } var i interface{} switch y := i.(type) { /*y=undef*/ case /*y=undef*/ int /*y=var:23*/ : case float32, /*y=undef*/ float64 /*y=var:23*/ : default /*y=var:23*/: println(y) } /*y=undef*/ switch int := i.(type) { case /*int=typename:0*/ int /*int=var:31*/ : println(int) default /*int=var:31*/ : } _ = param1 _ = res1 return } /*main=undef*/ ` info.Uses = make(map[*syntax.Name]Object) makePkg("main", mainSrc) mainScope := imports["main"].Scope() rx := regexp.MustCompile(`^/\*(\w*)=([\w:]*)\*/$`) base := syntax.NewFileBase("main") syntax.CommentsDo(strings.NewReader(mainSrc), func(line, col uint, text string) { pos := syntax.MakePos(base, line, col) // Syntax errors are not comments. if text[0] != '/' { t.Errorf("%s: %s", pos, text) return } // Parse the assertion in the comment. m := rx.FindStringSubmatch(text) if m == nil { t.Errorf("%s: bad comment: %s", pos, text) return } name, want := m[1], m[2] // Look up the name in the innermost enclosing scope. inner := mainScope.Innermost(pos) if inner == nil { t.Errorf("%s: at %s: can't find innermost scope", pos, text) return } got := "undef" if _, obj := inner.LookupParent(name, pos); obj != nil { kind := strings.ToLower(strings.TrimPrefix(reflect.TypeOf(obj).String(), "*types2.")) got = fmt.Sprintf("%s:%d", kind, obj.Pos().Line()) } if got != want { t.Errorf("%s: at %s: %s resolved to %s, want %s", pos, text, name, got, want) } }) // Check that for each referring identifier, // a lookup of its name on the innermost // enclosing scope returns the correct object. for id, wantObj := range info.Uses { inner := mainScope.Innermost(id.Pos()) if inner == nil { t.Errorf("%s: can't find innermost scope enclosing %q", id.Pos(), id.Value) continue } // Exclude selectors and qualified identifiers---lexical // refs only. (Ideally, we'd see if the AST parent is a // SelectorExpr, but that requires PathEnclosingInterval // from golang.org/x/tools/go/ast/astutil.) if id.Value == "X" { continue } _, gotObj := inner.LookupParent(id.Value, id.Pos()) if gotObj != wantObj { // Print the scope tree of mainScope in case of error. var printScopeTree func(indent string, s *Scope) printScopeTree = func(indent string, s *Scope) { t.Logf("%sscope %s %v-%v = %v", indent, ScopeComment(s), s.Pos(), s.End(), s.Names()) for i := range s.NumChildren() { printScopeTree(indent+" ", s.Child(i)) } } printScopeTree("", mainScope) t.Errorf("%s: Scope(%s).LookupParent(%s@%v) got %v, want %v [scopePos=%v]", id.Pos(), ScopeComment(inner), id.Value, id.Pos(), gotObj, wantObj, ObjectScopePos(wantObj)) continue } } } // newDefined creates a new defined type named T with the given underlying type. func newDefined(underlying Type) *Named { tname := NewTypeName(nopos, nil, "T", nil) return NewNamed(tname, underlying, nil) } func TestConvertibleTo(t *testing.T) { for _, test := range []struct { v, t Type want bool }{ {Typ[Int], Typ[Int], true}, {Typ[Int], Typ[Float32], true}, {Typ[Int], Typ[String], true}, {newDefined(Typ[Int]), Typ[Int], true}, {newDefined(new(Struct)), new(Struct), true}, {newDefined(Typ[Int]), new(Struct), false}, {Typ[UntypedInt], Typ[Int], true}, {NewSlice(Typ[Int]), NewArray(Typ[Int], 10), true}, {NewSlice(Typ[Int]), NewArray(Typ[Uint], 10), false}, {NewSlice(Typ[Int]), NewPointer(NewArray(Typ[Int], 10)), true}, {NewSlice(Typ[Int]), NewPointer(NewArray(Typ[Uint], 10)), false}, // Untyped string values are not permitted by the spec, so the behavior below is undefined. {Typ[UntypedString], Typ[String], true}, } { if got := ConvertibleTo(test.v, test.t); got != test.want { t.Errorf("ConvertibleTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want) } } } func TestAssignableTo(t *testing.T) { for _, test := range []struct { v, t Type want bool }{ {Typ[Int], Typ[Int], true}, {Typ[Int], Typ[Float32], false}, {newDefined(Typ[Int]), Typ[Int], false}, {newDefined(new(Struct)), new(Struct), true}, {Typ[UntypedBool], Typ[Bool], true}, {Typ[UntypedString], Typ[Bool], false}, // Neither untyped string nor untyped numeric assignments arise during // normal type checking, so the below behavior is technically undefined by // the spec. {Typ[UntypedString], Typ[String], true}, {Typ[UntypedInt], Typ[Int], true}, } { if got := AssignableTo(test.v, test.t); got != test.want { t.Errorf("AssignableTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want) } } } func TestIdentical(t *testing.T) { // For each test, we compare the types of objects X and Y in the source. tests := []struct { src string want bool }{ // Basic types. {"var X int; var Y int", true}, {"var X int; var Y string", false}, // TODO: add more tests for complex types. // Named types. {"type X int; type Y int", false}, // Aliases. {"type X = int; type Y = int", true}, // Functions. {`func X(int) string { return "" }; func Y(int) string { return "" }`, true}, {`func X() string { return "" }; func Y(int) string { return "" }`, false}, {`func X(int) string { return "" }; func Y(int) {}`, false}, // Generic functions. Type parameters should be considered identical modulo // renaming. See also go.dev/issue/49722. {`func X[P ~int](){}; func Y[Q ~int]() {}`, true}, {`func X[P1 any, P2 ~*P1](){}; func Y[Q1 any, Q2 ~*Q1]() {}`, true}, {`func X[P1 any, P2 ~[]P1](){}; func Y[Q1 any, Q2 ~*Q1]() {}`, false}, {`func X[P ~int](P){}; func Y[Q ~int](Q) {}`, true}, {`func X[P ~string](P){}; func Y[Q ~int](Q) {}`, false}, {`func X[P ~int]([]P){}; func Y[Q ~int]([]Q) {}`, true}, } for _, test := range tests { pkg := mustTypecheck("package p;"+test.src, nil, nil) X := pkg.Scope().Lookup("X") Y := pkg.Scope().Lookup("Y") if X == nil || Y == nil { t.Fatal("test must declare both X and Y") } if got := Identical(X.Type(), Y.Type()); got != test.want { t.Errorf("Identical(%s, %s) = %t, want %t", X.Type(), Y.Type(), got, test.want) } } } func TestIdentical_issue15173(t *testing.T) { // Identical should allow nil arguments and be symmetric. for _, test := range []struct { x, y Type want bool }{ {Typ[Int], Typ[Int], true}, {Typ[Int], nil, false}, {nil, Typ[Int], false}, {nil, nil, true}, } { if got := Identical(test.x, test.y); got != test.want { t.Errorf("Identical(%v, %v) = %t", test.x, test.y, got) } } } func TestIdenticalUnions(t *testing.T) { tname := NewTypeName(nopos, nil, "myInt", nil) myInt := NewNamed(tname, Typ[Int], nil) tmap := map[string]*Term{ "int": NewTerm(false, Typ[Int]), "~int": NewTerm(true, Typ[Int]), "string": NewTerm(false, Typ[String]), "~string": NewTerm(true, Typ[String]), "myInt": NewTerm(false, myInt), } makeUnion := func(s string) *Union { parts := strings.Split(s, "|") var terms []*Term for _, p := range parts { term := tmap[p] if term == nil { t.Fatalf("missing term %q", p) } terms = append(terms, term) } return NewUnion(terms) } for _, test := range []struct { x, y string want bool }{ // These tests are just sanity checks. The tests for type sets and // interfaces provide much more test coverage. {"int|~int", "~int", true}, {"myInt|~int", "~int", true}, {"int|string", "string|int", true}, {"int|int|string", "string|int", true}, {"myInt|string", "int|string", false}, } { x := makeUnion(test.x) y := makeUnion(test.y) if got := Identical(x, y); got != test.want { t.Errorf("Identical(%v, %v) = %t", test.x, test.y, got) } } } func TestIssue61737(t *testing.T) { // This test verifies that it is possible to construct invalid interfaces // containing duplicate methods using the go/types API. // // It must be possible for importers to construct such invalid interfaces. // Previously, this panicked. sig1 := NewSignatureType(nil, nil, nil, NewTuple(NewParam(nopos, nil, "", Typ[Int])), nil, false) sig2 := NewSignatureType(nil, nil, nil, NewTuple(NewParam(nopos, nil, "", Typ[String])), nil, false) methods := []*Func{ NewFunc(nopos, nil, "M", sig1), NewFunc(nopos, nil, "M", sig2), } embeddedMethods := []*Func{ NewFunc(nopos, nil, "M", sig2), } embedded := NewInterfaceType(embeddedMethods, nil) iface := NewInterfaceType(methods, []Type{embedded}) iface.NumMethods() // unlike go/types, there is no Complete() method, so we complete implicitly } func TestNewAlias_Issue65455(t *testing.T) { obj := NewTypeName(nopos, nil, "A", nil) alias := NewAlias(obj, Typ[Int]) alias.Underlying() // must not panic } func TestIssue15305(t *testing.T) { const src = "package p; func f() int16; var _ = f(undef)" f := mustParse(src) conf := Config{ Error: func(err error) {}, // allow errors } info := &Info{ Types: make(map[syntax.Expr]TypeAndValue), } conf.Check("p", []*syntax.File{f}, info) // ignore result for e, tv := range info.Types { if _, ok := e.(*syntax.CallExpr); ok { if tv.Type != Typ[Int16] { t.Errorf("CallExpr has type %v, want int16", tv.Type) } return } } t.Errorf("CallExpr has no type") } // TestCompositeLitTypes verifies that Info.Types registers the correct // types for composite literal expressions and composite literal type // expressions. func TestCompositeLitTypes(t *testing.T) { for i, test := range []struct { lit, typ string }{ {`[16]byte{}`, `[16]byte`}, {`[...]byte{}`, `[0]byte`}, // test for go.dev/issue/14092 {`[...]int{1, 2, 3}`, `[3]int`}, // test for go.dev/issue/14092 {`[...]int{90: 0, 98: 1, 2}`, `[100]int`}, // test for go.dev/issue/14092 {`[]int{}`, `[]int`}, {`map[string]bool{"foo": true}`, `map[string]bool`}, {`struct{}{}`, `struct{}`}, {`struct{x, y int; z complex128}{}`, `struct{x int; y int; z complex128}`}, } { f := mustParse(fmt.Sprintf("package p%d; var _ = %s", i, test.lit)) types := make(map[syntax.Expr]TypeAndValue) if _, err := new(Config).Check("p", []*syntax.File{f}, &Info{Types: types}); err != nil { t.Fatalf("%s: %v", test.lit, err) } cmptype := func(x syntax.Expr, want string) { tv, ok := types[x] if !ok { t.Errorf("%s: no Types entry found", test.lit) return } if tv.Type == nil { t.Errorf("%s: type is nil", test.lit) return } if got := tv.Type.String(); got != want { t.Errorf("%s: got %v, want %s", test.lit, got, want) } } // test type of composite literal expression rhs := f.DeclList[0].(*syntax.VarDecl).Values cmptype(rhs, test.typ) // test type of composite literal type expression cmptype(rhs.(*syntax.CompositeLit).Type, test.typ) } } // TestObjectParents verifies that objects have parent scopes or not // as specified by the Object interface. func TestObjectParents(t *testing.T) { const src = ` package p const C = 0 type T1 struct { a, b int T2 } type T2 interface { im1() im2() } func (T1) m1() {} func (*T1) m2() {} func f(x int) { y := x; print(y) } ` f := mustParse(src) info := &Info{ Defs: make(map[*syntax.Name]Object), } if _, err := new(Config).Check("p", []*syntax.File{f}, info); err != nil { t.Fatal(err) } for ident, obj := range info.Defs { if obj == nil { // only package names and implicit vars have a nil object // (in this test we only need to handle the package name) if ident.Value != "p" { t.Errorf("%v has nil object", ident) } continue } // struct fields, type-associated and interface methods // have no parent scope wantParent := true switch obj := obj.(type) { case *Var: if obj.IsField() { wantParent = false } case *Func: if obj.Type().(*Signature).Recv() != nil { // method wantParent = false } } gotParent := obj.Parent() != nil switch { case gotParent && !wantParent: t.Errorf("%v: want no parent, got %s", ident, obj.Parent()) case !gotParent && wantParent: t.Errorf("%v: no parent found", ident) } } } // TestFailedImport tests that we don't get follow-on errors // elsewhere in a package due to failing to import a package. func TestFailedImport(t *testing.T) { testenv.MustHaveGoBuild(t) const src = ` package p import foo "go/types/thisdirectorymustnotexistotherwisethistestmayfail/foo" // should only see an error here const c = foo.C type T = foo.T var v T = c func f(x T) T { return foo.F(x) } ` f := mustParse(src) files := []*syntax.File{f} // type-check using all possible importers for _, compiler := range []string{"gc", "gccgo", "source"} { errcount := 0 conf := Config{ Error: func(err error) { // we should only see the import error if errcount > 0 || !strings.Contains(err.Error(), "could not import") { t.Errorf("for %s importer, got unexpected error: %v", compiler, err) } errcount++ }, //Importer: importer.For(compiler, nil), } info := &Info{ Uses: make(map[*syntax.Name]Object), } pkg, _ := conf.Check("p", files, info) if pkg == nil { t.Errorf("for %s importer, type-checking failed to return a package", compiler) continue } imports := pkg.Imports() if len(imports) != 1 { t.Errorf("for %s importer, got %d imports, want 1", compiler, len(imports)) continue } imp := imports[0] if imp.Name() != "foo" { t.Errorf(`for %s importer, got %q, want "foo"`, compiler, imp.Name()) continue } // verify that all uses of foo refer to the imported package foo (imp) for ident, obj := range info.Uses { if ident.Value == "foo" { if obj, ok := obj.(*PkgName); ok { if obj.Imported() != imp { t.Errorf("%s resolved to %v; want %v", ident.Value, obj.Imported(), imp) } } else { t.Errorf("%s resolved to %v; want package name", ident.Value, obj) } } } } } func TestInstantiate(t *testing.T) { // eventually we like more tests but this is a start const src = "package p; type T[P any] *T[P]" pkg := mustTypecheck(src, nil, nil) // type T should have one type parameter T := pkg.Scope().Lookup("T").Type().(*Named) if n := T.TypeParams().Len(); n != 1 { t.Fatalf("expected 1 type parameter; found %d", n) } // instantiation should succeed (no endless recursion) // even with a nil *Checker res, err := Instantiate(nil, T, []Type{Typ[Int]}, false) if err != nil { t.Fatal(err) } // instantiated type should point to itself if p := res.Underlying().(*Pointer).Elem(); p != res { t.Fatalf("unexpected result type: %s points to %s", res, p) } } func TestInstantiateConcurrent(t *testing.T) { const src = `package p type I[P any] interface { m(P) n() P } type J = I[int] type Nested[P any] *interface{b(P)} type K = Nested[string] ` pkg := mustTypecheck(src, nil, nil) insts := []*Interface{ pkg.Scope().Lookup("J").Type().Underlying().(*Interface), pkg.Scope().Lookup("K").Type().Underlying().(*Pointer).Elem().(*Interface), } // Use the interface instances concurrently. for _, inst := range insts { var ( counts [2]int // method counts methods [2][]string // method strings ) var wg sync.WaitGroup for i := 0; i < 2; i++ { i := i wg.Add(1) go func() { defer wg.Done() counts[i] = inst.NumMethods() for mi := 0; mi < counts[i]; mi++ { methods[i] = append(methods[i], inst.Method(mi).String()) } }() } wg.Wait() if counts[0] != counts[1] { t.Errorf("mismatching method counts for %s: %d vs %d", inst, counts[0], counts[1]) continue } for i := 0; i < counts[0]; i++ { if m0, m1 := methods[0][i], methods[1][i]; m0 != m1 { t.Errorf("mismatching methods for %s: %s vs %s", inst, m0, m1) } } } } func TestInstantiateErrors(t *testing.T) { tests := []struct { src string // by convention, T must be the type being instantiated targs []Type wantAt int // -1 indicates no error }{ {"type T[P interface{~string}] int", []Type{Typ[Int]}, 0}, {"type T[P1 interface{int}, P2 interface{~string}] int", []Type{Typ[Int], Typ[Int]}, 1}, {"type T[P1 any, P2 interface{~[]P1}] int", []Type{Typ[Int], NewSlice(Typ[String])}, 1}, {"type T[P1 interface{~[]P2}, P2 any] int", []Type{NewSlice(Typ[String]), Typ[Int]}, 0}, } for _, test := range tests { src := "package p; " + test.src pkg := mustTypecheck(src, nil, nil) T := pkg.Scope().Lookup("T").Type().(*Named) _, err := Instantiate(nil, T, test.targs, true) if err == nil { t.Fatalf("Instantiate(%v, %v) returned nil error, want non-nil", T, test.targs) } var argErr *ArgumentError if !errors.As(err, &argErr) { t.Fatalf("Instantiate(%v, %v): error is not an *ArgumentError", T, test.targs) } if argErr.Index != test.wantAt { t.Errorf("Instantiate(%v, %v): error at index %d, want index %d", T, test.targs, argErr.Index, test.wantAt) } } } func TestArgumentErrorUnwrapping(t *testing.T) { var err error = &ArgumentError{ Index: 1, Err: Error{Msg: "test"}, } var e Error if !errors.As(err, &e) { t.Fatalf("error %v does not wrap types.Error", err) } if e.Msg != "test" { t.Errorf("e.Msg = %q, want %q", e.Msg, "test") } } func TestInstanceIdentity(t *testing.T) { imports := make(testImporter) conf := Config{Importer: imports} makePkg := func(src string) { f := mustParse(src) name := f.PkgName.Value pkg, err := conf.Check(name, []*syntax.File{f}, nil) if err != nil { t.Fatal(err) } imports[name] = pkg } makePkg(`package lib; type T[P any] struct{}`) makePkg(`package a; import "lib"; var A lib.T[int]`) makePkg(`package b; import "lib"; var B lib.T[int]`) a := imports["a"].Scope().Lookup("A") b := imports["b"].Scope().Lookup("B") if !Identical(a.Type(), b.Type()) { t.Errorf("mismatching types: a.A: %s, b.B: %s", a.Type(), b.Type()) } } // TestInstantiatedObjects verifies properties of instantiated objects. func TestInstantiatedObjects(t *testing.T) { const src = ` package p type T[P any] struct { field P } func (recv *T[Q]) concreteMethod(mParam Q) (mResult Q) { return } type FT[P any] func(ftParam P) (ftResult P) func F[P any](fParam P) (fResult P){ return } type I[P any] interface { interfaceMethod(P) } type R[P any] T[P] func (R[P]) m() {} // having a method triggers expansion of R var ( t T[int] ft FT[int] f = F[int] i I[int] ) func fn() { var r R[int] _ = r } ` info := &Info{ Defs: make(map[*syntax.Name]Object), } f := mustParse(src) conf := Config{} pkg, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, info) if err != nil { t.Fatal(err) } lookup := func(name string) Type { return pkg.Scope().Lookup(name).Type() } fnScope := pkg.Scope().Lookup("fn").(*Func).Scope() tests := []struct { name string obj Object }{ // Struct fields {"field", lookup("t").Underlying().(*Struct).Field(0)}, {"field", fnScope.Lookup("r").Type().Underlying().(*Struct).Field(0)}, // Methods and method fields {"concreteMethod", lookup("t").(*Named).Method(0)}, {"recv", lookup("t").(*Named).Method(0).Type().(*Signature).Recv()}, {"mParam", lookup("t").(*Named).Method(0).Type().(*Signature).Params().At(0)}, {"mResult", lookup("t").(*Named).Method(0).Type().(*Signature).Results().At(0)}, // Interface methods {"interfaceMethod", lookup("i").Underlying().(*Interface).Method(0)}, // Function type fields {"ftParam", lookup("ft").Underlying().(*Signature).Params().At(0)}, {"ftResult", lookup("ft").Underlying().(*Signature).Results().At(0)}, // Function fields {"fParam", lookup("f").(*Signature).Params().At(0)}, {"fResult", lookup("f").(*Signature).Results().At(0)}, } // Collect all identifiers by name. idents := make(map[string][]*syntax.Name) syntax.Inspect(f, func(n syntax.Node) bool { if id, ok := n.(*syntax.Name); ok { idents[id.Value] = append(idents[id.Value], id) } return true }) for _, test := range tests { test := test t.Run(test.name, func(t *testing.T) { if got := len(idents[test.name]); got != 1 { t.Fatalf("found %d identifiers named %s, want 1", got, test.name) } ident := idents[test.name][0] def := info.Defs[ident] if def == test.obj { t.Fatalf("info.Defs[%s] contains the test object", test.name) } if orig := originObject(test.obj); def != orig { t.Errorf("info.Defs[%s] does not match obj.Origin()", test.name) } if def.Pkg() != test.obj.Pkg() { t.Errorf("Pkg() = %v, want %v", def.Pkg(), test.obj.Pkg()) } if def.Name() != test.obj.Name() { t.Errorf("Name() = %v, want %v", def.Name(), test.obj.Name()) } if def.Pos() != test.obj.Pos() { t.Errorf("Pos() = %v, want %v", def.Pos(), test.obj.Pos()) } if def.Parent() != test.obj.Parent() { t.Fatalf("Parent() = %v, want %v", def.Parent(), test.obj.Parent()) } if def.Exported() != test.obj.Exported() { t.Fatalf("Exported() = %v, want %v", def.Exported(), test.obj.Exported()) } if def.Id() != test.obj.Id() { t.Fatalf("Id() = %v, want %v", def.Id(), test.obj.Id()) } // String and Type are expected to differ. }) } } func originObject(obj Object) Object { switch obj := obj.(type) { case *Var: return obj.Origin() case *Func: return obj.Origin() } return obj } func TestImplements(t *testing.T) { const src = ` package p type EmptyIface interface{} type I interface { m() } type C interface { m() ~int } type Integer interface{ int8 | int16 | int32 | int64 } type EmptyTypeSet interface{ Integer ~string } type N1 int func (N1) m() {} type N2 int func (*N2) m() {} type N3 int func (N3) m(int) {} type N4 string func (N4) m() type Bad Bad // invalid type ` f := mustParse(src) conf := Config{Error: func(error) {}} pkg, _ := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil) lookup := func(tname string) Type { return pkg.Scope().Lookup(tname).Type() } var ( EmptyIface = lookup("EmptyIface").Underlying().(*Interface) I = lookup("I").(*Named) II = I.Underlying().(*Interface) C = lookup("C").(*Named) CI = C.Underlying().(*Interface) Integer = lookup("Integer").Underlying().(*Interface) EmptyTypeSet = lookup("EmptyTypeSet").Underlying().(*Interface) N1 = lookup("N1") N1p = NewPointer(N1) N2 = lookup("N2") N2p = NewPointer(N2) N3 = lookup("N3") N4 = lookup("N4") Bad = lookup("Bad") ) tests := []struct { V Type T *Interface want bool }{ {I, II, true}, {I, CI, false}, {C, II, true}, {C, CI, true}, {Typ[Int8], Integer, true}, {Typ[Int64], Integer, true}, {Typ[String], Integer, false}, {EmptyTypeSet, II, true}, {EmptyTypeSet, EmptyTypeSet, true}, {Typ[Int], EmptyTypeSet, false}, {N1, II, true}, {N1, CI, true}, {N1p, II, true}, {N1p, CI, false}, {N2, II, false}, {N2, CI, false}, {N2p, II, true}, {N2p, CI, false}, {N3, II, false}, {N3, CI, false}, {N4, II, true}, {N4, CI, false}, {Bad, II, false}, {Bad, CI, false}, {Bad, EmptyIface, true}, } for _, test := range tests { if got := Implements(test.V, test.T); got != test.want { t.Errorf("Implements(%s, %s) = %t, want %t", test.V, test.T, got, test.want) } // The type assertion x.(T) is valid if T is an interface or if T implements the type of x. // The assertion is never valid if T is a bad type. V := test.T T := test.V want := false if _, ok := T.Underlying().(*Interface); (ok || Implements(T, V)) && T != Bad { want = true } if got := AssertableTo(V, T); got != want { t.Errorf("AssertableTo(%s, %s) = %t, want %t", V, T, got, want) } } } func TestMissingMethodAlternative(t *testing.T) { const src = ` package p type T interface { m() } type V0 struct{} func (V0) m() {} type V1 struct{} type V2 struct{} func (V2) m() int type V3 struct{} func (*V3) m() type V4 struct{} func (V4) M() ` pkg := mustTypecheck(src, nil, nil) T := pkg.Scope().Lookup("T").Type().Underlying().(*Interface) lookup := func(name string) (*Func, bool) { return MissingMethod(pkg.Scope().Lookup(name).Type(), T, true) } // V0 has method m with correct signature. Should not report wrongType. method, wrongType := lookup("V0") if method != nil || wrongType { t.Fatalf("V0: got method = %v, wrongType = %v", method, wrongType) } checkMissingMethod := func(tname string, reportWrongType bool) { method, wrongType := lookup(tname) if method == nil || method.Name() != "m" || wrongType != reportWrongType { t.Fatalf("%s: got method = %v, wrongType = %v", tname, method, wrongType) } } // V1 has no method m. Should not report wrongType. checkMissingMethod("V1", false) // V2 has method m with wrong signature type (ignoring receiver). Should report wrongType. checkMissingMethod("V2", true) // V3 has no method m but it exists on *V3. Should report wrongType. checkMissingMethod("V3", true) // V4 has no method m but has M. Should not report wrongType. checkMissingMethod("V4", false) } func TestErrorURL(t *testing.T) { conf := Config{ErrorURL: " [go.dev/e/%s]"} // test case for a one-line error const src1 = ` package p var _ T ` _, err := typecheck(src1, &conf, nil) if err == nil || !strings.HasSuffix(err.Error(), " [go.dev/e/UndeclaredName]") { t.Errorf("src1: unexpected error: got %v", err) } // test case for a multi-line error const src2 = ` package p func f() int { return 0 } var _ = f(1, 2) ` _, err = typecheck(src2, &conf, nil) if err == nil || !strings.Contains(err.Error(), " [go.dev/e/WrongArgCount]\n") { t.Errorf("src1: unexpected error: got %v", err) } } func TestModuleVersion(t *testing.T) { // version go1.dd must be able to typecheck go1.dd.0, go1.dd.1, etc. goversion := fmt.Sprintf("go1.%d", goversion.Version) for _, v := range []string{ goversion, goversion + ".0", goversion + ".1", goversion + ".rc", } { conf := Config{GoVersion: v} pkg := mustTypecheck("package p", &conf, nil) if pkg.GoVersion() != conf.GoVersion { t.Errorf("got %s; want %s", pkg.GoVersion(), conf.GoVersion) } } } func TestFileVersions(t *testing.T) { for _, test := range []struct { goVersion string fileVersion string wantVersion string }{ {"", "", ""}, // no versions specified {"go1.19", "", "go1.19"}, // module version specified {"", "go1.20", ""}, // file upgrade ignored {"go1.19", "go1.20", "go1.20"}, // file upgrade permitted {"go1.20", "go1.19", "go1.20"}, // file downgrade not permitted {"go1.21", "go1.19", "go1.19"}, // file downgrade permitted (module version is >= go1.21) // versions containing release numbers // (file versions containing release numbers are considered invalid) {"go1.19.0", "", "go1.19.0"}, // no file version specified {"go1.20", "go1.20.1", "go1.20"}, // file upgrade ignored {"go1.20.1", "go1.20", "go1.20.1"}, // file upgrade ignored {"go1.20.1", "go1.21", "go1.21"}, // file upgrade permitted {"go1.20.1", "go1.19", "go1.20.1"}, // file downgrade not permitted {"go1.21.1", "go1.19.1", "go1.21.1"}, // file downgrade not permitted (invalid file version) {"go1.21.1", "go1.19", "go1.19"}, // file downgrade permitted (module version is >= go1.21) } { var src string if test.fileVersion != "" { src = "//go:build " + test.fileVersion + "\n" } src += "package p" conf := Config{GoVersion: test.goVersion} versions := make(map[*syntax.PosBase]string) var info Info info.FileVersions = versions mustTypecheck(src, &conf, &info) n := 0 for _, v := range info.FileVersions { want := test.wantVersion if v != want { t.Errorf("%q: unexpected file version: got %v, want %v", src, v, want) } n++ } if n != 1 { t.Errorf("%q: incorrect number of map entries: got %d", src, n) } } } PK ! 94� � � resolver_test.gonu �[��� // Copyright 2011 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 types2_test import ( "cmd/compile/internal/syntax" "fmt" "internal/testenv" "sort" "testing" . "cmd/compile/internal/types2" ) type resolveTestImporter struct { importer ImporterFrom imported map[string]bool } func (imp *resolveTestImporter) Import(string) (*Package, error) { panic("should not be called") } func (imp *resolveTestImporter) ImportFrom(path, srcDir string, mode ImportMode) (*Package, error) { if mode != 0 { panic("mode must be 0") } if imp.importer == nil { imp.importer = defaultImporter().(ImporterFrom) imp.imported = make(map[string]bool) } pkg, err := imp.importer.ImportFrom(path, srcDir, mode) if err != nil { return nil, err } imp.imported[path] = true return pkg, nil } func TestResolveIdents(t *testing.T) { testenv.MustHaveGoBuild(t) sources := []string{ ` package p import "fmt" import "math" const pi = math.Pi func sin(x float64) float64 { return math.Sin(x) } var Println = fmt.Println `, ` package p import "fmt" type errorStringer struct { fmt.Stringer; error } func f() string { _ = "foo" return fmt.Sprintf("%d", g()) } func g() (x int) { return } `, ` package p import . "go/parser" import "sync" func h() Mode { return ImportsOnly } var _, x int = 1, 2 func init() {} type T struct{ *sync.Mutex; a, b, c int} type I interface{ m() } var _ = T{a: 1, b: 2, c: 3} func (_ T) m() {} func (T) _() {} var i I var _ = i.m func _(s []int) { for i, x := range s { _, _ = i, x } } func _(x interface{}) { switch x := x.(type) { case int: _ = x } switch {} // implicit 'true' tag } `, ` package p type S struct{} func (T) _() {} func (T) _() {} `, ` package p func _() { L0: L1: goto L0 for { goto L1 } if true { goto L2 } L2: } `, } pkgnames := []string{ "fmt", "math", } // parse package files var files []*syntax.File for _, src := range sources { files = append(files, mustParse(src)) } // resolve and type-check package AST importer := new(resolveTestImporter) conf := Config{Importer: importer} uses := make(map[*syntax.Name]Object) defs := make(map[*syntax.Name]Object) _, err := conf.Check("testResolveIdents", files, &Info{Defs: defs, Uses: uses}) if err != nil { t.Fatal(err) } // check that all packages were imported for _, name := range pkgnames { if !importer.imported[name] { t.Errorf("package %s not imported", name) } } // check that qualified identifiers are resolved for _, f := range files { syntax.Inspect(f, func(n syntax.Node) bool { if s, ok := n.(*syntax.SelectorExpr); ok { if x, ok := s.X.(*syntax.Name); ok { obj := uses[x] if obj == nil { t.Errorf("%s: unresolved qualified identifier %s", x.Pos(), x.Value) return false } if _, ok := obj.(*PkgName); ok && uses[s.Sel] == nil { t.Errorf("%s: unresolved selector %s", s.Sel.Pos(), s.Sel.Value) return false } return false } return true } return true }) } for id, obj := range uses { if obj == nil { t.Errorf("%s: Uses[%s] == nil", id.Pos(), id.Value) } } // Check that each identifier in the source is found in uses or defs or both. // We need the foundUses/Defs maps (rather than just deleting the found objects // from the uses and defs maps) because syntax.Walk traverses shared nodes multiple // times (e.g. types in field lists such as "a, b, c int"). foundUses := make(map[*syntax.Name]bool) foundDefs := make(map[*syntax.Name]bool) var both []string for _, f := range files { syntax.Inspect(f, func(n syntax.Node) bool { if x, ok := n.(*syntax.Name); ok { var objects int if _, found := uses[x]; found { objects |= 1 foundUses[x] = true } if _, found := defs[x]; found { objects |= 2 foundDefs[x] = true } switch objects { case 0: t.Errorf("%s: unresolved identifier %s", x.Pos(), x.Value) case 3: both = append(both, x.Value) } return false } return true }) } // check the expected set of idents that are simultaneously uses and defs sort.Strings(both) if got, want := fmt.Sprint(both), "[Mutex Stringer error]"; got != want { t.Errorf("simultaneous uses/defs = %s, want %s", got, want) } // any left-over identifiers didn't exist in the source for x := range uses { if !foundUses[x] { t.Errorf("%s: identifier %s not present in source", x.Pos(), x.Value) } } for x := range defs { if !foundDefs[x] { t.Errorf("%s: identifier %s not present in source", x.Pos(), x.Value) } } // TODO(gri) add tests to check ImplicitObj callbacks } PK ! ��� typeterm.gonu �[��� // Copyright 2021 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 types2 // A term describes elementary type sets: // // ∅: (*term)(nil) == ∅ // set of no types (empty set) // 𝓤: &term{} == 𝓤 // set of all types (𝓤niverse) // T: &term{false, T} == {T} // set of type T // ~t: &term{true, t} == {t' | under(t') == t} // set of types with underlying type t type term struct { tilde bool // valid if typ != nil typ Type } func (x *term) String() string { switch { case x == nil: return "∅" case x.typ == nil: return "𝓤" case x.tilde: return "~" + x.typ.String() default: return x.typ.String() } } // equal reports whether x and y represent the same type set. func (x *term) equal(y *term) bool { // easy cases switch { case x == nil || y == nil: return x == y case x.typ == nil || y.typ == nil: return x.typ == y.typ } // ∅ ⊂ x, y ⊂ 𝓤 return x.tilde == y.tilde && Identical(x.typ, y.typ) } // union returns the union x ∪ y: zero, one, or two non-nil terms. func (x *term) union(y *term) (_, _ *term) { // easy cases switch { case x == nil && y == nil: return nil, nil // ∅ ∪ ∅ == ∅ case x == nil: return y, nil // ∅ ∪ y == y case y == nil: return x, nil // x ∪ ∅ == x case x.typ == nil: return x, nil // 𝓤 ∪ y == 𝓤 case y.typ == nil: return y, nil // x ∪ 𝓤 == 𝓤 } // ∅ ⊂ x, y ⊂ 𝓤 if x.disjoint(y) { return x, y // x ∪ y == (x, y) if x ∩ y == ∅ } // x.typ == y.typ // ~t ∪ ~t == ~t // ~t ∪ T == ~t // T ∪ ~t == ~t // T ∪ T == T if x.tilde || !y.tilde { return x, nil } return y, nil } // intersect returns the intersection x ∩ y. func (x *term) intersect(y *term) *term { // easy cases switch { case x == nil || y == nil: return nil // ∅ ∩ y == ∅ and ∩ ∅ == ∅ case x.typ == nil: return y // 𝓤 ∩ y == y case y.typ == nil: return x // x ∩ 𝓤 == x } // ∅ ⊂ x, y ⊂ 𝓤 if x.disjoint(y) { return nil // x ∩ y == ∅ if x ∩ y == ∅ } // x.typ == y.typ // ~t ∩ ~t == ~t // ~t ∩ T == T // T ∩ ~t == T // T ∩ T == T if !x.tilde || y.tilde { return x } return y } // includes reports whether t ∈ x. func (x *term) includes(t Type) bool { // easy cases switch { case x == nil: return false // t ∈ ∅ == false case x.typ == nil: return true // t ∈ 𝓤 == true } // ∅ ⊂ x ⊂ 𝓤 u := t if x.tilde { u = under(u) } return Identical(x.typ, u) } // subsetOf reports whether x ⊆ y. func (x *term) subsetOf(y *term) bool { // easy cases switch { case x == nil: return true // ∅ ⊆ y == true case y == nil: return false // x ⊆ ∅ == false since x != ∅ case y.typ == nil: return true // x ⊆ 𝓤 == true case x.typ == nil: return false // 𝓤 ⊆ y == false since y != 𝓤 } // ∅ ⊂ x, y ⊂ 𝓤 if x.disjoint(y) { return false // x ⊆ y == false if x ∩ y == ∅ } // x.typ == y.typ // ~t ⊆ ~t == true // ~t ⊆ T == false // T ⊆ ~t == true // T ⊆ T == true return !x.tilde || y.tilde } // disjoint reports whether x ∩ y == ∅. // x.typ and y.typ must not be nil. func (x *term) disjoint(y *term) bool { if debug && (x.typ == nil || y.typ == nil) { panic("invalid argument(s)") } ux := x.typ if y.tilde { ux = under(ux) } uy := y.typ if x.tilde { uy = under(uy) } return !Identical(ux, uy) } PK ! �EAWs Ws decl.gonu �[��� // Copyright 2014 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 types2 import ( "cmd/compile/internal/syntax" "fmt" "go/constant" . "internal/types/errors" ) func (err *error_) recordAltDecl(obj Object) { if pos := obj.Pos(); pos.IsKnown() { // We use "other" rather than "previous" here because // the first declaration seen may not be textually // earlier in the source. err.errorf(pos, "other declaration of %s", obj.Name()) } } func (check *Checker) declare(scope *Scope, id *syntax.Name, obj Object, pos syntax.Pos) { // spec: "The blank identifier, represented by the underscore // character _, may be used in a declaration like any other // identifier but the declaration does not introduce a new // binding." if obj.Name() != "_" { if alt := scope.Insert(obj); alt != nil { var err error_ err.code = DuplicateDecl err.errorf(obj, "%s redeclared in this block", obj.Name()) err.recordAltDecl(alt) check.report(&err) return } obj.setScopePos(pos) } if id != nil { check.recordDef(id, obj) } } // pathString returns a string of the form a->b-> ... ->g for a path [a, b, ... g]. func pathString(path []Object) string { var s string for i, p := range path { if i > 0 { s += "->" } s += p.Name() } return s } // objDecl type-checks the declaration of obj in its respective (file) environment. // For the meaning of def, see Checker.definedType, in typexpr.go. func (check *Checker) objDecl(obj Object, def *TypeName) { if check.conf.Trace && obj.Type() == nil { if check.indent == 0 { fmt.Println() // empty line between top-level objects for readability } check.trace(obj.Pos(), "-- checking %s (%s, objPath = %s)", obj, obj.color(), pathString(check.objPath)) check.indent++ defer func() { check.indent-- check.trace(obj.Pos(), "=> %s (%s)", obj, obj.color()) }() } // Checking the declaration of obj means inferring its type // (and possibly its value, for constants). // An object's type (and thus the object) may be in one of // three states which are expressed by colors: // // - an object whose type is not yet known is painted white (initial color) // - an object whose type is in the process of being inferred is painted grey // - an object whose type is fully inferred is painted black // // During type inference, an object's color changes from white to grey // to black (pre-declared objects are painted black from the start). // A black object (i.e., its type) can only depend on (refer to) other black // ones. White and grey objects may depend on white and black objects. // A dependency on a grey object indicates a cycle which may or may not be // valid. // // When objects turn grey, they are pushed on the object path (a stack); // they are popped again when they turn black. Thus, if a grey object (a // cycle) is encountered, it is on the object path, and all the objects // it depends on are the remaining objects on that path. Color encoding // is such that the color value of a grey object indicates the index of // that object in the object path. // During type-checking, white objects may be assigned a type without // traversing through objDecl; e.g., when initializing constants and // variables. Update the colors of those objects here (rather than // everywhere where we set the type) to satisfy the color invariants. if obj.color() == white && obj.Type() != nil { obj.setColor(black) return } switch obj.color() { case white: assert(obj.Type() == nil) // All color values other than white and black are considered grey. // Because black and white are < grey, all values >= grey are grey. // Use those values to encode the object's index into the object path. obj.setColor(grey + color(check.push(obj))) defer func() { check.pop().setColor(black) }() case black: assert(obj.Type() != nil) return default: // Color values other than white or black are considered grey. fallthrough case grey: // We have a (possibly invalid) cycle. // In the existing code, this is marked by a non-nil type // for the object except for constants and variables whose // type may be non-nil (known), or nil if it depends on the // not-yet known initialization value. // In the former case, set the type to Typ[Invalid] because // we have an initialization cycle. The cycle error will be // reported later, when determining initialization order. // TODO(gri) Report cycle here and simplify initialization // order code. switch obj := obj.(type) { case *Const: if !check.validCycle(obj) || obj.typ == nil { obj.typ = Typ[Invalid] } case *Var: if !check.validCycle(obj) || obj.typ == nil { obj.typ = Typ[Invalid] } case *TypeName: if !check.validCycle(obj) { // break cycle // (without this, calling underlying() // below may lead to an endless loop // if we have a cycle for a defined // (*Named) type) obj.typ = Typ[Invalid] } case *Func: if !check.validCycle(obj) { // Don't set obj.typ to Typ[Invalid] here // because plenty of code type-asserts that // functions have a *Signature type. Grey // functions have their type set to an empty // signature which makes it impossible to // initialize a variable with the function. } default: unreachable() } assert(obj.Type() != nil) return } d := check.objMap[obj] if d == nil { check.dump("%v: %s should have been declared", obj.Pos(), obj) unreachable() } // save/restore current environment and set up object environment defer func(env environment) { check.environment = env }(check.environment) check.environment = environment{ scope: d.file, } // Const and var declarations must not have initialization // cycles. We track them by remembering the current declaration // in check.decl. Initialization expressions depending on other // consts, vars, or functions, add dependencies to the current // check.decl. switch obj := obj.(type) { case *Const: check.decl = d // new package-level const decl check.constDecl(obj, d.vtyp, d.init, d.inherited) case *Var: check.decl = d // new package-level var decl check.varDecl(obj, d.lhs, d.vtyp, d.init) case *TypeName: // invalid recursive types are detected via path check.typeDecl(obj, d.tdecl, def) check.collectMethods(obj) // methods can only be added to top-level types case *Func: // functions may be recursive - no need to track dependencies check.funcDecl(obj, d) default: unreachable() } } // validCycle reports whether the cycle starting with obj is valid and // reports an error if it is not. func (check *Checker) validCycle(obj Object) (valid bool) { // The object map contains the package scope objects and the non-interface methods. if debug { info := check.objMap[obj] inObjMap := info != nil && (info.fdecl == nil || info.fdecl.Recv == nil) // exclude methods isPkgObj := obj.Parent() == check.pkg.scope if isPkgObj != inObjMap { check.dump("%v: inconsistent object map for %s (isPkgObj = %v, inObjMap = %v)", obj.Pos(), obj, isPkgObj, inObjMap) unreachable() } } // Count cycle objects. assert(obj.color() >= grey) start := obj.color() - grey // index of obj in objPath cycle := check.objPath[start:] tparCycle := false // if set, the cycle is through a type parameter list nval := 0 // number of (constant or variable) values in the cycle; valid if !generic ndef := 0 // number of type definitions in the cycle; valid if !generic loop: for _, obj := range cycle { switch obj := obj.(type) { case *Const, *Var: nval++ case *TypeName: // If we reach a generic type that is part of a cycle // and we are in a type parameter list, we have a cycle // through a type parameter list, which is invalid. if check.inTParamList && isGeneric(obj.typ) { tparCycle = true break loop } // Determine if the type name is an alias or not. For // package-level objects, use the object map which // provides syntactic information (which doesn't rely // on the order in which the objects are set up). For // local objects, we can rely on the order, so use // the object's predicate. // TODO(gri) It would be less fragile to always access // the syntactic information. We should consider storing // this information explicitly in the object. var alias bool if check.enableAlias { alias = obj.IsAlias() } else { if d := check.objMap[obj]; d != nil { alias = d.tdecl.Alias // package-level object } else { alias = obj.IsAlias() // function local object } } if !alias { ndef++ } case *Func: // ignored for now default: unreachable() } } if check.conf.Trace { check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle)) if tparCycle { check.trace(obj.Pos(), "## cycle contains: generic type in a type parameter list") } else { check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) } defer func() { if valid { check.trace(obj.Pos(), "=> cycle is valid") } else { check.trace(obj.Pos(), "=> error: cycle is invalid") } }() } if !tparCycle { // A cycle involving only constants and variables is invalid but we // ignore them here because they are reported via the initialization // cycle check. if nval == len(cycle) { return true } // A cycle involving only types (and possibly functions) must have at least // one type definition to be permitted: If there is no type definition, we // have a sequence of alias type names which will expand ad infinitum. if nval == 0 && ndef > 0 { return true } } check.cycleError(cycle) return false } // cycleError reports a declaration cycle starting with // the object in cycle that is "first" in the source. func (check *Checker) cycleError(cycle []Object) { // name returns the (possibly qualified) object name. // This is needed because with generic types, cycles // may refer to imported types. See go.dev/issue/50788. // TODO(gri) This functionality is used elsewhere. Factor it out. name := func(obj Object) string { return packagePrefix(obj.Pkg(), check.qualifier) + obj.Name() } // TODO(gri) Should we start with the last (rather than the first) object in the cycle // since that is the earliest point in the source where we start seeing the // cycle? That would be more consistent with other error messages. i := firstInSrc(cycle) obj := cycle[i] objName := name(obj) // If obj is a type alias, mark it as valid (not broken) in order to avoid follow-on errors. tname, _ := obj.(*TypeName) if tname != nil && tname.IsAlias() { // If we use Alias nodes, it is initialized with Typ[Invalid]. // TODO(gri) Adjust this code if we initialize with nil. if !check.enableAlias { check.validAlias(tname, Typ[Invalid]) } } // report a more concise error for self references if len(cycle) == 1 { if tname != nil { check.errorf(obj, InvalidDeclCycle, "invalid recursive type: %s refers to itself", objName) } else { check.errorf(obj, InvalidDeclCycle, "invalid cycle in declaration: %s refers to itself", objName) } return } var err error_ err.code = InvalidDeclCycle if tname != nil { err.errorf(obj, "invalid recursive type %s", objName) } else { err.errorf(obj, "invalid cycle in declaration of %s", objName) } for range cycle { err.errorf(obj, "%s refers to", objName) i++ if i >= len(cycle) { i = 0 } obj = cycle[i] objName = name(obj) } err.errorf(obj, "%s", objName) check.report(&err) } // firstInSrc reports the index of the object with the "smallest" // source position in path. path must not be empty. func firstInSrc(path []Object) int { fst, pos := 0, path[0].Pos() for i, t := range path[1:] { if cmpPos(t.Pos(), pos) < 0 { fst, pos = i+1, t.Pos() } } return fst } func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr, inherited bool) { assert(obj.typ == nil) // use the correct value of iota and errpos defer func(iota constant.Value, errpos syntax.Pos) { check.iota = iota check.errpos = errpos }(check.iota, check.errpos) check.iota = obj.val check.errpos = nopos // provide valid constant value under all circumstances obj.val = constant.MakeUnknown() // determine type, if any if typ != nil { t := check.typ(typ) if !isConstType(t) { // don't report an error if the type is an invalid C (defined) type // (go.dev/issue/22090) if isValid(under(t)) { check.errorf(typ, InvalidConstType, "invalid constant type %s", t) } obj.typ = Typ[Invalid] return } obj.typ = t } // check initialization var x operand if init != nil { if inherited { // The initialization expression is inherited from a previous // constant declaration, and (error) positions refer to that // expression and not the current constant declaration. Use // the constant identifier position for any errors during // init expression evaluation since that is all we have // (see issues go.dev/issue/42991, go.dev/issue/42992). check.errpos = obj.pos } check.expr(nil, &x, init) } check.initConst(obj, &x) } func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init syntax.Expr) { assert(obj.typ == nil) // determine type, if any if typ != nil { obj.typ = check.varType(typ) // We cannot spread the type to all lhs variables if there // are more than one since that would mark them as checked // (see Checker.objDecl) and the assignment of init exprs, // if any, would not be checked. // // TODO(gri) If we have no init expr, we should distribute // a given type otherwise we need to re-evalate the type // expr for each lhs variable, leading to duplicate work. } // check initialization if init == nil { if typ == nil { // error reported before by arityMatch obj.typ = Typ[Invalid] } return } if lhs == nil || len(lhs) == 1 { assert(lhs == nil || lhs[0] == obj) var x operand check.expr(newTarget(obj.typ, obj.name), &x, init) check.initVar(obj, &x, "variable declaration") return } if debug { // obj must be one of lhs found := false for _, lhs := range lhs { if obj == lhs { found = true break } } if !found { panic("inconsistent lhs") } } // We have multiple variables on the lhs and one init expr. // Make sure all variables have been given the same type if // one was specified, otherwise they assume the type of the // init expression values (was go.dev/issue/15755). if typ != nil { for _, lhs := range lhs { lhs.typ = obj.typ } } check.initVars(lhs, []syntax.Expr{init}, nil) } // isImportedConstraint reports whether typ is an imported type constraint. func (check *Checker) isImportedConstraint(typ Type) bool { named := asNamed(typ) if named == nil || named.obj.pkg == check.pkg || named.obj.pkg == nil { return false } u, _ := named.under().(*Interface) return u != nil && !u.IsMethodSet() } func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *TypeName) { assert(obj.typ == nil) var rhs Type check.later(func() { if t := asNamed(obj.typ); t != nil { // type may be invalid check.validType(t) } // If typ is local, an error was already reported where typ is specified/defined. _ = check.isImportedConstraint(rhs) && check.verifyVersionf(tdecl.Type, go1_18, "using type constraint %s", rhs) }).describef(obj, "validType(%s)", obj.Name()) aliasDecl := tdecl.Alias if aliasDecl && tdecl.TParamList != nil { // The parser will ensure this but we may still get an invalid AST. // Complain and continue as regular type definition. check.error(tdecl, BadDecl, "generic type cannot be alias") aliasDecl = false } // alias declaration if aliasDecl { check.verifyVersionf(tdecl, go1_9, "type aliases") if check.enableAlias { // TODO(gri) Should be able to use nil instead of Typ[Invalid] to mark // the alias as incomplete. Currently this causes problems // with certain cycles. Investigate. alias := check.newAlias(obj, Typ[Invalid]) setDefType(def, alias) rhs = check.definedType(tdecl.Type, obj) assert(rhs != nil) alias.fromRHS = rhs Unalias(alias) // resolve alias.actual } else { check.brokenAlias(obj) rhs = check.typ(tdecl.Type) check.validAlias(obj, rhs) } return } // type definition or generic type declaration named := check.newNamed(obj, nil, nil) setDefType(def, named) if tdecl.TParamList != nil { check.openScope(tdecl, "type parameters") defer check.closeScope() check.collectTypeParams(&named.tparams, tdecl.TParamList) } // determine underlying type of named rhs = check.definedType(tdecl.Type, obj) assert(rhs != nil) named.fromRHS = rhs // If the underlying type was not set while type-checking the right-hand // side, it is invalid and an error should have been reported elsewhere. if named.underlying == nil { named.underlying = Typ[Invalid] } // Disallow a lone type parameter as the RHS of a type declaration (go.dev/issue/45639). // We don't need this restriction anymore if we make the underlying type of a type // parameter its constraint interface: if the RHS is a lone type parameter, we will // use its underlying type (like we do for any RHS in a type declaration), and its // underlying type is an interface and the type declaration is well defined. if isTypeParam(rhs) { check.error(tdecl.Type, MisplacedTypeParam, "cannot use a type parameter as RHS in type declaration") named.underlying = Typ[Invalid] } } func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Field) { tparams := make([]*TypeParam, len(list)) // Declare type parameters up-front. // The scope of type parameters starts at the beginning of the type parameter // list (so we can have mutually recursive parameterized type bounds). if len(list) > 0 { scopePos := list[0].Pos() for i, f := range list { tparams[i] = check.declareTypeParam(f.Name, scopePos) } } // Set the type parameters before collecting the type constraints because // the parameterized type may be used by the constraints (go.dev/issue/47887). // Example: type T[P T[P]] interface{} *dst = bindTParams(tparams) // Signal to cycle detection that we are in a type parameter list. // We can only be inside one type parameter list at any given time: // function closures may appear inside a type parameter list but they // cannot be generic, and their bodies are processed in delayed and // sequential fashion. Note that with each new declaration, we save // the existing environment and restore it when done; thus inTParamList // is true exactly only when we are in a specific type parameter list. assert(!check.inTParamList) check.inTParamList = true defer func() { check.inTParamList = false }() // Keep track of bounds for later validation. var bound Type for i, f := range list { // Optimization: Re-use the previous type bound if it hasn't changed. // This also preserves the grouped output of type parameter lists // when printing type strings. if i == 0 || f.Type != list[i-1].Type { bound = check.bound(f.Type) if isTypeParam(bound) { // We may be able to allow this since it is now well-defined what // the underlying type and thus type set of a type parameter is. // But we may need some additional form of cycle detection within // type parameter lists. check.error(f.Type, MisplacedTypeParam, "cannot use a type parameter as constraint") bound = Typ[Invalid] } } tparams[i].bound = bound } } func (check *Checker) bound(x syntax.Expr) Type { // A type set literal of the form ~T and A|B may only appear as constraint; // embed it in an implicit interface so that only interface type-checking // needs to take care of such type expressions. if op, _ := x.(*syntax.Operation); op != nil && (op.Op == syntax.Tilde || op.Op == syntax.Or) { t := check.typ(&syntax.InterfaceType{MethodList: []*syntax.Field{{Type: x}}}) // mark t as implicit interface if all went well if t, _ := t.(*Interface); t != nil { t.implicit = true } return t } return check.typ(x) } func (check *Checker) declareTypeParam(name *syntax.Name, scopePos syntax.Pos) *TypeParam { // Use Typ[Invalid] for the type constraint to ensure that a type // is present even if the actual constraint has not been assigned // yet. // TODO(gri) Need to systematically review all uses of type parameter // constraints to make sure we don't rely on them if they // are not properly set yet. tname := NewTypeName(name.Pos(), check.pkg, name.Value, nil) tpar := check.newTypeParam(tname, Typ[Invalid]) // assigns type to tname as a side-effect check.declare(check.scope, name, tname, scopePos) return tpar } func (check *Checker) collectMethods(obj *TypeName) { // get associated methods // (Checker.collectObjects only collects methods with non-blank names; // Checker.resolveBaseTypeName ensures that obj is not an alias name // if it has attached methods.) methods := check.methods[obj] if methods == nil { return } delete(check.methods, obj) assert(!check.objMap[obj].tdecl.Alias) // don't use TypeName.IsAlias (requires fully set up object) // use an objset to check for name conflicts var mset objset // spec: "If the base type is a struct type, the non-blank method // and field names must be distinct." base := asNamed(obj.typ) // shouldn't fail but be conservative if base != nil { assert(base.TypeArgs().Len() == 0) // collectMethods should not be called on an instantiated type // See go.dev/issue/52529: we must delay the expansion of underlying here, as // base may not be fully set-up. check.later(func() { check.checkFieldUniqueness(base) }).describef(obj, "verifying field uniqueness for %v", base) // Checker.Files may be called multiple times; additional package files // may add methods to already type-checked types. Add pre-existing methods // so that we can detect redeclarations. for i := 0; i < base.NumMethods(); i++ { m := base.Method(i) assert(m.name != "_") assert(mset.insert(m) == nil) } } // add valid methods for _, m := range methods { // spec: "For a base type, the non-blank names of methods bound // to it must be unique." assert(m.name != "_") if alt := mset.insert(m); alt != nil { if alt.Pos().IsKnown() { check.errorf(m.pos, DuplicateMethod, "method %s.%s already declared at %s", obj.Name(), m.name, alt.Pos()) } else { check.errorf(m.pos, DuplicateMethod, "method %s.%s already declared", obj.Name(), m.name) } continue } if base != nil { base.AddMethod(m) } } } func (check *Checker) checkFieldUniqueness(base *Named) { if t, _ := base.under().(*Struct); t != nil { var mset objset for i := 0; i < base.NumMethods(); i++ { m := base.Method(i) assert(m.name != "_") assert(mset.insert(m) == nil) } // Check that any non-blank field names of base are distinct from its // method names. for _, fld := range t.fields { if fld.name != "_" { if alt := mset.insert(fld); alt != nil { // Struct fields should already be unique, so we should only // encounter an alternate via collision with a method name. _ = alt.(*Func) // For historical consistency, we report the primary error on the // method, and the alt decl on the field. var err error_ err.code = DuplicateFieldAndMethod err.errorf(alt, "field and method with the same name %s", fld.name) err.recordAltDecl(fld) check.report(&err) } } } } } func (check *Checker) funcDecl(obj *Func, decl *declInfo) { assert(obj.typ == nil) // func declarations cannot use iota assert(check.iota == nil) sig := new(Signature) obj.typ = sig // guard against cycles // Avoid cycle error when referring to method while type-checking the signature. // This avoids a nuisance in the best case (non-parameterized receiver type) and // since the method is not a type, we get an error. If we have a parameterized // receiver type, instantiating the receiver type leads to the instantiation of // its methods, and we don't want a cycle error in that case. // TODO(gri) review if this is correct and/or whether we still need this? saved := obj.color_ obj.color_ = black fdecl := decl.fdecl check.funcType(sig, fdecl.Recv, fdecl.TParamList, fdecl.Type) obj.color_ = saved // Set the scope's extent to the complete "func (...) { ... }" // so that Scope.Innermost works correctly. sig.scope.pos = fdecl.Pos() sig.scope.end = syntax.EndPos(fdecl) if len(fdecl.TParamList) > 0 && fdecl.Body == nil { check.softErrorf(fdecl, BadDecl, "generic function is missing function body") } // function body must be type-checked after global declarations // (functions implemented elsewhere have no body) if !check.conf.IgnoreFuncBodies && fdecl.Body != nil { check.later(func() { check.funcBody(decl, obj.name, sig, fdecl.Body, nil) }).describef(obj, "func %s", obj.name) } } func (check *Checker) declStmt(list []syntax.Decl) { pkg := check.pkg first := -1 // index of first ConstDecl in the current group, or -1 var last *syntax.ConstDecl // last ConstDecl with init expressions, or nil for index, decl := range list { if _, ok := decl.(*syntax.ConstDecl); !ok { first = -1 // we're not in a constant declaration } switch s := decl.(type) { case *syntax.ConstDecl: top := len(check.delayed) // iota is the index of the current constDecl within the group if first < 0 || s.Group == nil || list[index-1].(*syntax.ConstDecl).Group != s.Group { first = index last = nil } iota := constant.MakeInt64(int64(index - first)) // determine which initialization expressions to use inherited := true switch { case s.Type != nil || s.Values != nil: last = s inherited = false case last == nil: last = new(syntax.ConstDecl) // make sure last exists inherited = false } // declare all constants lhs := make([]*Const, len(s.NameList)) values := syntax.UnpackListExpr(last.Values) for i, name := range s.NameList { obj := NewConst(name.Pos(), pkg, name.Value, nil, iota) lhs[i] = obj var init syntax.Expr if i < len(values) { init = values[i] } check.constDecl(obj, last.Type, init, inherited) } // Constants must always have init values. check.arity(s.Pos(), s.NameList, values, true, inherited) // process function literals in init expressions before scope changes check.processDelayed(top) // spec: "The scope of a constant or variable identifier declared // inside a function begins at the end of the ConstSpec or VarSpec // (ShortVarDecl for short variable declarations) and ends at the // end of the innermost containing block." scopePos := syntax.EndPos(s) for i, name := range s.NameList { check.declare(check.scope, name, lhs[i], scopePos) } case *syntax.VarDecl: top := len(check.delayed) lhs0 := make([]*Var, len(s.NameList)) for i, name := range s.NameList { lhs0[i] = NewVar(name.Pos(), pkg, name.Value, nil) } // initialize all variables values := syntax.UnpackListExpr(s.Values) for i, obj := range lhs0 { var lhs []*Var var init syntax.Expr switch len(values) { case len(s.NameList): // lhs and rhs match init = values[i] case 1: // rhs is expected to be a multi-valued expression lhs = lhs0 init = values[0] default: if i < len(values) { init = values[i] } } check.varDecl(obj, lhs, s.Type, init) if len(values) == 1 { // If we have a single lhs variable we are done either way. // If we have a single rhs expression, it must be a multi- // valued expression, in which case handling the first lhs // variable will cause all lhs variables to have a type // assigned, and we are done as well. if debug { for _, obj := range lhs0 { assert(obj.typ != nil) } } break } } // If we have no type, we must have values. if s.Type == nil || values != nil { check.arity(s.Pos(), s.NameList, values, false, false) } // process function literals in init expressions before scope changes check.processDelayed(top) // declare all variables // (only at this point are the variable scopes (parents) set) scopePos := syntax.EndPos(s) // see constant declarations for i, name := range s.NameList { // see constant declarations check.declare(check.scope, name, lhs0[i], scopePos) } case *syntax.TypeDecl: obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Value, nil) // spec: "The scope of a type identifier declared inside a function // begins at the identifier in the TypeSpec and ends at the end of // the innermost containing block." scopePos := s.Name.Pos() check.declare(check.scope, s.Name, obj, scopePos) // mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl) obj.setColor(grey + color(check.push(obj))) check.typeDecl(obj, s, nil) check.pop().setColor(black) default: check.errorf(s, InvalidSyntaxTree, "unknown syntax.Decl node %T", s) } } } PK ! �9�Y Y self_test.gonu �[��� // Copyright 2013 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 types2_test import ( "cmd/compile/internal/syntax" "internal/testenv" "path" "path/filepath" "runtime" "testing" "time" . "cmd/compile/internal/types2" ) func TestSelf(t *testing.T) { testenv.MustHaveGoBuild(t) // The Go command is needed for the importer to determine the locations of stdlib .a files. files, err := pkgFiles(".") if err != nil { t.Fatal(err) } conf := Config{Importer: defaultImporter()} _, err = conf.Check("cmd/compile/internal/types2", files, nil) if err != nil { t.Fatal(err) } } func BenchmarkCheck(b *testing.B) { testenv.MustHaveGoBuild(b) // The Go command is needed for the importer to determine the locations of stdlib .a files. for _, p := range []string{ filepath.Join("src", "net", "http"), filepath.Join("src", "go", "parser"), filepath.Join("src", "go", "constant"), filepath.Join("src", "runtime"), filepath.Join("src", "go", "internal", "gcimporter"), } { b.Run(path.Base(p), func(b *testing.B) { path := filepath.Join(runtime.GOROOT(), p) for _, ignoreFuncBodies := range []bool{false, true} { name := "funcbodies" if ignoreFuncBodies { name = "nofuncbodies" } b.Run(name, func(b *testing.B) { b.Run("info", func(b *testing.B) { runbench(b, path, ignoreFuncBodies, true) }) b.Run("noinfo", func(b *testing.B) { runbench(b, path, ignoreFuncBodies, false) }) }) } }) } } func runbench(b *testing.B, path string, ignoreFuncBodies, writeInfo bool) { files, err := pkgFiles(path) if err != nil { b.Fatal(err) } // determine line count var lines uint for _, f := range files { lines += f.EOF.Line() } b.ResetTimer() start := time.Now() for i := 0; i < b.N; i++ { conf := Config{ IgnoreFuncBodies: ignoreFuncBodies, Importer: defaultImporter(), } var info *Info if writeInfo { info = &Info{ Types: make(map[syntax.Expr]TypeAndValue), Defs: make(map[*syntax.Name]Object), Uses: make(map[*syntax.Name]Object), Implicits: make(map[syntax.Node]Object), Selections: make(map[*syntax.SelectorExpr]*Selection), Scopes: make(map[syntax.Node]*Scope), } } if _, err := conf.Check(path, files, info); err != nil { b.Fatal(err) } } b.StopTimer() b.ReportMetric(float64(lines)*float64(b.N)/time.Since(start).Seconds(), "lines/s") } func pkgFiles(path string) ([]*syntax.File, error) { filenames, err := pkgFilenames(path, true) // from stdlib_test.go if err != nil { return nil, err } var files []*syntax.File for _, filename := range filenames { file, err := syntax.ParseFile(filename, nil, nil, 0) if err != nil { return nil, err } files = append(files, file) } return files, nil } PK ! ����m �m unify.gonu �[��� // Copyright 2020 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. // This file implements type unification. // // Type unification attempts to make two types x and y structurally // equivalent by determining the types for a given list of (bound) // type parameters which may occur within x and y. If x and y are // structurally different (say []T vs chan T), or conflicting // types are determined for type parameters, unification fails. // If unification succeeds, as a side-effect, the types of the // bound type parameters may be determined. // // Unification typically requires multiple calls u.unify(x, y) to // a given unifier u, with various combinations of types x and y. // In each call, additional type parameter types may be determined // as a side effect and recorded in u. // If a call fails (returns false), unification fails. // // In the unification context, structural equivalence of two types // ignores the difference between a defined type and its underlying // type if one type is a defined type and the other one is not. // It also ignores the difference between an (external, unbound) // type parameter and its core type. // If two types are not structurally equivalent, they cannot be Go // identical types. On the other hand, if they are structurally // equivalent, they may be Go identical or at least assignable, or // they may be in the type set of a constraint. // Whether they indeed are identical or assignable is determined // upon instantiation and function argument passing. package types2 import ( "bytes" "fmt" "sort" "strings" ) const ( // Upper limit for recursion depth. Used to catch infinite recursions // due to implementation issues (e.g., see issues go.dev/issue/48619, go.dev/issue/48656). unificationDepthLimit = 50 // Whether to panic when unificationDepthLimit is reached. // If disabled, a recursion depth overflow results in a (quiet) // unification failure. panicAtUnificationDepthLimit = true // If enableCoreTypeUnification is set, unification will consider // the core types, if any, of non-local (unbound) type parameters. enableCoreTypeUnification = true // If traceInference is set, unification will print a trace of its operation. // Interpretation of trace: // x ≡ y attempt to unify types x and y // p ➞ y type parameter p is set to type y (p is inferred to be y) // p ⇄ q type parameters p and q match (p is inferred to be q and vice versa) // x ≢ y types x and y cannot be unified // [p, q, ...] ➞ [x, y, ...] mapping from type parameters to types traceInference = false ) // A unifier maintains a list of type parameters and // corresponding types inferred for each type parameter. // A unifier is created by calling newUnifier. type unifier struct { // handles maps each type parameter to its inferred type through // an indirection *Type called (inferred type) "handle". // Initially, each type parameter has its own, separate handle, // with a nil (i.e., not yet inferred) type. // After a type parameter P is unified with a type parameter Q, // P and Q share the same handle (and thus type). This ensures // that inferring the type for a given type parameter P will // automatically infer the same type for all other parameters // unified (joined) with P. handles map[*TypeParam]*Type depth int // recursion depth during unification enableInterfaceInference bool // use shared methods for better inference } // newUnifier returns a new unifier initialized with the given type parameter // and corresponding type argument lists. The type argument list may be shorter // than the type parameter list, and it may contain nil types. Matching type // parameters and arguments must have the same index. func newUnifier(tparams []*TypeParam, targs []Type, enableInterfaceInference bool) *unifier { assert(len(tparams) >= len(targs)) handles := make(map[*TypeParam]*Type, len(tparams)) // Allocate all handles up-front: in a correct program, all type parameters // must be resolved and thus eventually will get a handle. // Also, sharing of handles caused by unified type parameters is rare and // so it's ok to not optimize for that case (and delay handle allocation). for i, x := range tparams { var t Type if i < len(targs) { t = targs[i] } handles[x] = &t } return &unifier{handles, 0, enableInterfaceInference} } // unifyMode controls the behavior of the unifier. type unifyMode uint const ( // If assign is set, we are unifying types involved in an assignment: // they may match inexactly at the top, but element types must match // exactly. assign unifyMode = 1 << iota // If exact is set, types unify if they are identical (or can be // made identical with suitable arguments for type parameters). // Otherwise, a named type and a type literal unify if their // underlying types unify, channel directions are ignored, and // if there is an interface, the other type must implement the // interface. exact ) func (m unifyMode) String() string { switch m { case 0: return "inexact" case assign: return "assign" case exact: return "exact" case assign | exact: return "assign, exact" } return fmt.Sprintf("mode %d", m) } // unify attempts to unify x and y and reports whether it succeeded. // As a side-effect, types may be inferred for type parameters. // The mode parameter controls how types are compared. func (u *unifier) unify(x, y Type, mode unifyMode) bool { return u.nify(x, y, mode, nil) } func (u *unifier) tracef(format string, args ...interface{}) { fmt.Println(strings.Repeat(". ", u.depth) + sprintf(nil, true, format, args...)) } // String returns a string representation of the current mapping // from type parameters to types. func (u *unifier) String() string { // sort type parameters for reproducible strings tparams := make(typeParamsById, len(u.handles)) i := 0 for tpar := range u.handles { tparams[i] = tpar i++ } sort.Sort(tparams) var buf bytes.Buffer w := newTypeWriter(&buf, nil) w.byte('[') for i, x := range tparams { if i > 0 { w.string(", ") } w.typ(x) w.string(": ") w.typ(u.at(x)) } w.byte(']') return buf.String() } type typeParamsById []*TypeParam func (s typeParamsById) Len() int { return len(s) } func (s typeParamsById) Less(i, j int) bool { return s[i].id < s[j].id } func (s typeParamsById) Swap(i, j int) { s[i], s[j] = s[j], s[i] } // join unifies the given type parameters x and y. // If both type parameters already have a type associated with them // and they are not joined, join fails and returns false. func (u *unifier) join(x, y *TypeParam) bool { if traceInference { u.tracef("%s ⇄ %s", x, y) } switch hx, hy := u.handles[x], u.handles[y]; { case hx == hy: // Both type parameters already share the same handle. Nothing to do. case *hx != nil && *hy != nil: // Both type parameters have (possibly different) inferred types. Cannot join. return false case *hx != nil: // Only type parameter x has an inferred type. Use handle of x. u.setHandle(y, hx) // This case is treated like the default case. // case *hy != nil: // // Only type parameter y has an inferred type. Use handle of y. // u.setHandle(x, hy) default: // Neither type parameter has an inferred type. Use handle of y. u.setHandle(x, hy) } return true } // asTypeParam returns x.(*TypeParam) if x is a type parameter recorded with u. // Otherwise, the result is nil. func (u *unifier) asTypeParam(x Type) *TypeParam { if x, _ := x.(*TypeParam); x != nil { if _, found := u.handles[x]; found { return x } } return nil } // setHandle sets the handle for type parameter x // (and all its joined type parameters) to h. func (u *unifier) setHandle(x *TypeParam, h *Type) { hx := u.handles[x] assert(hx != nil) for y, hy := range u.handles { if hy == hx { u.handles[y] = h } } } // at returns the (possibly nil) type for type parameter x. func (u *unifier) at(x *TypeParam) Type { return *u.handles[x] } // set sets the type t for type parameter x; // t must not be nil. func (u *unifier) set(x *TypeParam, t Type) { assert(t != nil) if traceInference { u.tracef("%s ➞ %s", x, t) } *u.handles[x] = t } // unknowns returns the number of type parameters for which no type has been set yet. func (u *unifier) unknowns() int { n := 0 for _, h := range u.handles { if *h == nil { n++ } } return n } // inferred returns the list of inferred types for the given type parameter list. // The result is never nil and has the same length as tparams; result types that // could not be inferred are nil. Corresponding type parameters and result types // have identical indices. func (u *unifier) inferred(tparams []*TypeParam) []Type { list := make([]Type, len(tparams)) for i, x := range tparams { list[i] = u.at(x) } return list } // asInterface returns the underlying type of x as an interface if // it is a non-type parameter interface. Otherwise it returns nil. func asInterface(x Type) (i *Interface) { if _, ok := x.(*TypeParam); !ok { i, _ = under(x).(*Interface) } return i } // nify implements the core unification algorithm which is an // adapted version of Checker.identical. For changes to that // code the corresponding changes should be made here. // Must not be called directly from outside the unifier. func (u *unifier) nify(x, y Type, mode unifyMode, p *ifacePair) (result bool) { u.depth++ if traceInference { u.tracef("%s ≡ %s\t// %s", x, y, mode) } defer func() { if traceInference && !result { u.tracef("%s ≢ %s", x, y) } u.depth-- }() x = Unalias(x) y = Unalias(y) // nothing to do if x == y if x == y { return true } // Stop gap for cases where unification fails. if u.depth > unificationDepthLimit { if traceInference { u.tracef("depth %d >= %d", u.depth, unificationDepthLimit) } if panicAtUnificationDepthLimit { panic("unification reached recursion depth limit") } return false } // Unification is symmetric, so we can swap the operands. // Ensure that if we have at least one // - defined type, make sure one is in y // - type parameter recorded with u, make sure one is in x if asNamed(x) != nil || u.asTypeParam(y) != nil { if traceInference { u.tracef("%s ≡ %s\t// swap", y, x) } x, y = y, x } // Unification will fail if we match a defined type against a type literal. // If we are matching types in an assignment, at the top-level, types with // the same type structure are permitted as long as at least one of them // is not a defined type. To accommodate for that possibility, we continue // unification with the underlying type of a defined type if the other type // is a type literal. This is controlled by the exact unification mode. // We also continue if the other type is a basic type because basic types // are valid underlying types and may appear as core types of type constraints. // If we exclude them, inferred defined types for type parameters may not // match against the core types of their constraints (even though they might // correctly match against some of the types in the constraint's type set). // Finally, if unification (incorrectly) succeeds by matching the underlying // type of a defined type against a basic type (because we include basic types // as type literals here), and if that leads to an incorrectly inferred type, // we will fail at function instantiation or argument assignment time. // // If we have at least one defined type, there is one in y. if ny := asNamed(y); mode&exact == 0 && ny != nil && isTypeLit(x) && !(u.enableInterfaceInference && IsInterface(x)) { if traceInference { u.tracef("%s ≡ under %s", x, ny) } y = ny.under() // Per the spec, a defined type cannot have an underlying type // that is a type parameter. assert(!isTypeParam(y)) // x and y may be identical now if x == y { return true } } // Cases where at least one of x or y is a type parameter recorded with u. // If we have at least one type parameter, there is one in x. // If we have exactly one type parameter, because it is in x, // isTypeLit(x) is false and y was not changed above. In other // words, if y was a defined type, it is still a defined type // (relevant for the logic below). switch px, py := u.asTypeParam(x), u.asTypeParam(y); { case px != nil && py != nil: // both x and y are type parameters if u.join(px, py) { return true } // both x and y have an inferred type - they must match return u.nify(u.at(px), u.at(py), mode, p) case px != nil: // x is a type parameter, y is not if x := u.at(px); x != nil { // x has an inferred type which must match y if u.nify(x, y, mode, p) { // We have a match, possibly through underlying types. xi := asInterface(x) yi := asInterface(y) xn := asNamed(x) != nil yn := asNamed(y) != nil // If we have two interfaces, what to do depends on // whether they are named and their method sets. if xi != nil && yi != nil { // Both types are interfaces. // If both types are defined types, they must be identical // because unification doesn't know which type has the "right" name. if xn && yn { return Identical(x, y) } // In all other cases, the method sets must match. // The types unified so we know that corresponding methods // match and we can simply compare the number of methods. // TODO(gri) We may be able to relax this rule and select // the more general interface. But if one of them is a defined // type, it's not clear how to choose and whether we introduce // an order dependency or not. Requiring the same method set // is conservative. if len(xi.typeSet().methods) != len(yi.typeSet().methods) { return false } } else if xi != nil || yi != nil { // One but not both of them are interfaces. // In this case, either x or y could be viable matches for the corresponding // type parameter, which means choosing either introduces an order dependence. // Therefore, we must fail unification (go.dev/issue/60933). return false } // If we have inexact unification and one of x or y is a defined type, select the // defined type. This ensures that in a series of types, all matching against the // same type parameter, we infer a defined type if there is one, independent of // order. Type inference or assignment may fail, which is ok. // Selecting a defined type, if any, ensures that we don't lose the type name; // and since we have inexact unification, a value of equally named or matching // undefined type remains assignable (go.dev/issue/43056). // // Similarly, if we have inexact unification and there are no defined types but // channel types, select a directed channel, if any. This ensures that in a series // of unnamed types, all matching against the same type parameter, we infer the // directed channel if there is one, independent of order. // Selecting a directional channel, if any, ensures that a value of another // inexactly unifying channel type remains assignable (go.dev/issue/62157). // // If we have multiple defined channel types, they are either identical or we // have assignment conflicts, so we can ignore directionality in this case. // // If we have defined and literal channel types, a defined type wins to avoid // order dependencies. if mode&exact == 0 { switch { case xn: // x is a defined type: nothing to do. case yn: // x is not a defined type and y is a defined type: select y. u.set(px, y) default: // Neither x nor y are defined types. if yc, _ := under(y).(*Chan); yc != nil && yc.dir != SendRecv { // y is a directed channel type: select y. u.set(px, y) } } } return true } return false } // otherwise, infer type from y u.set(px, y) return true } // x != y if we get here assert(x != y) // If u.EnableInterfaceInference is set and we don't require exact unification, // if both types are interfaces, one interface must have a subset of the // methods of the other and corresponding method signatures must unify. // If only one type is an interface, all its methods must be present in the // other type and corresponding method signatures must unify. if u.enableInterfaceInference && mode&exact == 0 { // One or both interfaces may be defined types. // Look under the name, but not under type parameters (go.dev/issue/60564). xi := asInterface(x) yi := asInterface(y) // If we have two interfaces, check the type terms for equivalence, // and unify common methods if possible. if xi != nil && yi != nil { xset := xi.typeSet() yset := yi.typeSet() if xset.comparable != yset.comparable { return false } // For now we require terms to be equal. // We should be able to relax this as well, eventually. if !xset.terms.equal(yset.terms) { return false } // Interface types are the only types where cycles can occur // that are not "terminated" via named types; and such cycles // can only be created via method parameter types that are // anonymous interfaces (directly or indirectly) embedding // the current interface. Example: // // type T interface { // m() interface{T} // } // // If two such (differently named) interfaces are compared, // endless recursion occurs if the cycle is not detected. // // If x and y were compared before, they must be equal // (if they were not, the recursion would have stopped); // search the ifacePair stack for the same pair. // // This is a quadratic algorithm, but in practice these stacks // are extremely short (bounded by the nesting depth of interface // type declarations that recur via parameter types, an extremely // rare occurrence). An alternative implementation might use a // "visited" map, but that is probably less efficient overall. q := &ifacePair{xi, yi, p} for p != nil { if p.identical(q) { return true // same pair was compared before } p = p.prev } // The method set of x must be a subset of the method set // of y or vice versa, and the common methods must unify. xmethods := xset.methods ymethods := yset.methods // The smaller method set must be the subset, if it exists. if len(xmethods) > len(ymethods) { xmethods, ymethods = ymethods, xmethods } // len(xmethods) <= len(ymethods) // Collect the ymethods in a map for quick lookup. ymap := make(map[string]*Func, len(ymethods)) for _, ym := range ymethods { ymap[ym.Id()] = ym } // All xmethods must exist in ymethods and corresponding signatures must unify. for _, xm := range xmethods { if ym := ymap[xm.Id()]; ym == nil || !u.nify(xm.typ, ym.typ, exact, p) { return false } } return true } // We don't have two interfaces. If we have one, make sure it's in xi. if yi != nil { xi = yi y = x } // If we have one interface, at a minimum each of the interface methods // must be implemented and thus unify with a corresponding method from // the non-interface type, otherwise unification fails. if xi != nil { // All xi methods must exist in y and corresponding signatures must unify. xmethods := xi.typeSet().methods for _, xm := range xmethods { obj, _, _ := LookupFieldOrMethod(y, false, xm.pkg, xm.name) if ym, _ := obj.(*Func); ym == nil || !u.nify(xm.typ, ym.typ, exact, p) { return false } } return true } } // Unless we have exact unification, neither x nor y are interfaces now. // Except for unbound type parameters (see below), x and y must be structurally // equivalent to unify. // If we get here and x or y is a type parameter, they are unbound // (not recorded with the unifier). // Ensure that if we have at least one type parameter, it is in x // (the earlier swap checks for _recorded_ type parameters only). // This ensures that the switch switches on the type parameter. // // TODO(gri) Factor out type parameter handling from the switch. if isTypeParam(y) { if traceInference { u.tracef("%s ≡ %s\t// swap", y, x) } x, y = y, x } // Type elements (array, slice, etc. elements) use emode for unification. // Element types must match exactly if the types are used in an assignment. emode := mode if mode&assign != 0 { emode |= exact } switch x := x.(type) { case *Basic: // Basic types are singletons except for the rune and byte // aliases, thus we cannot solely rely on the x == y check // above. See also comment in TypeName.IsAlias. if y, ok := y.(*Basic); ok { return x.kind == y.kind } case *Array: // Two array types unify if they have the same array length // and their element types unify. if y, ok := y.(*Array); ok { // If one or both array lengths are unknown (< 0) due to some error, // assume they are the same to avoid spurious follow-on errors. return (x.len < 0 || y.len < 0 || x.len == y.len) && u.nify(x.elem, y.elem, emode, p) } case *Slice: // Two slice types unify if their element types unify. if y, ok := y.(*Slice); ok { return u.nify(x.elem, y.elem, emode, p) } case *Struct: // Two struct types unify if they have the same sequence of fields, // and if corresponding fields have the same names, their (field) types unify, // and they have identical tags. Two embedded fields are considered to have the same // name. Lower-case field names from different packages are always different. if y, ok := y.(*Struct); ok { if x.NumFields() == y.NumFields() { for i, f := range x.fields { g := y.fields[i] if f.embedded != g.embedded || x.Tag(i) != y.Tag(i) || !f.sameId(g.pkg, g.name) || !u.nify(f.typ, g.typ, emode, p) { return false } } return true } } case *Pointer: // Two pointer types unify if their base types unify. if y, ok := y.(*Pointer); ok { return u.nify(x.base, y.base, emode, p) } case *Tuple: // Two tuples types unify if they have the same number of elements // and the types of corresponding elements unify. if y, ok := y.(*Tuple); ok { if x.Len() == y.Len() { if x != nil { for i, v := range x.vars { w := y.vars[i] if !u.nify(v.typ, w.typ, mode, p) { return false } } } return true } } case *Signature: // Two function types unify if they have the same number of parameters // and result values, corresponding parameter and result types unify, // and either both functions are variadic or neither is. // Parameter and result names are not required to match. // TODO(gri) handle type parameters or document why we can ignore them. if y, ok := y.(*Signature); ok { return x.variadic == y.variadic && u.nify(x.params, y.params, emode, p) && u.nify(x.results, y.results, emode, p) } case *Interface: assert(!u.enableInterfaceInference || mode&exact != 0) // handled before this switch // Two interface types unify if they have the same set of methods with // the same names, and corresponding function types unify. // Lower-case method names from different packages are always different. // The order of the methods is irrelevant. if y, ok := y.(*Interface); ok { xset := x.typeSet() yset := y.typeSet() if xset.comparable != yset.comparable { return false } if !xset.terms.equal(yset.terms) { return false } a := xset.methods b := yset.methods if len(a) == len(b) { // Interface types are the only types where cycles can occur // that are not "terminated" via named types; and such cycles // can only be created via method parameter types that are // anonymous interfaces (directly or indirectly) embedding // the current interface. Example: // // type T interface { // m() interface{T} // } // // If two such (differently named) interfaces are compared, // endless recursion occurs if the cycle is not detected. // // If x and y were compared before, they must be equal // (if they were not, the recursion would have stopped); // search the ifacePair stack for the same pair. // // This is a quadratic algorithm, but in practice these stacks // are extremely short (bounded by the nesting depth of interface // type declarations that recur via parameter types, an extremely // rare occurrence). An alternative implementation might use a // "visited" map, but that is probably less efficient overall. q := &ifacePair{x, y, p} for p != nil { if p.identical(q) { return true // same pair was compared before } p = p.prev } if debug { assertSortedMethods(a) assertSortedMethods(b) } for i, f := range a { g := b[i] if f.Id() != g.Id() || !u.nify(f.typ, g.typ, exact, q) { return false } } return true } } case *Map: // Two map types unify if their key and value types unify. if y, ok := y.(*Map); ok { return u.nify(x.key, y.key, emode, p) && u.nify(x.elem, y.elem, emode, p) } case *Chan: // Two channel types unify if their value types unify // and if they have the same direction. // The channel direction is ignored for inexact unification. if y, ok := y.(*Chan); ok { return (mode&exact == 0 || x.dir == y.dir) && u.nify(x.elem, y.elem, emode, p) } case *Named: // Two named types unify if their type names originate in the same type declaration. // If they are instantiated, their type argument lists must unify. if y := asNamed(y); y != nil { // Check type arguments before origins so they unify // even if the origins don't match; for better error // messages (see go.dev/issue/53692). xargs := x.TypeArgs().list() yargs := y.TypeArgs().list() if len(xargs) != len(yargs) { return false } for i, xarg := range xargs { if !u.nify(xarg, yargs[i], mode, p) { return false } } return identicalOrigin(x, y) } case *TypeParam: // x must be an unbound type parameter (see comment above). if debug { assert(u.asTypeParam(x) == nil) } // By definition, a valid type argument must be in the type set of // the respective type constraint. Therefore, the type argument's // underlying type must be in the set of underlying types of that // constraint. If there is a single such underlying type, it's the // constraint's core type. It must match the type argument's under- // lying type, irrespective of whether the actual type argument, // which may be a defined type, is actually in the type set (that // will be determined at instantiation time). // Thus, if we have the core type of an unbound type parameter, // we know the structure of the possible types satisfying such // parameters. Use that core type for further unification // (see go.dev/issue/50755 for a test case). if enableCoreTypeUnification { // Because the core type is always an underlying type, // unification will take care of matching against a // defined or literal type automatically. // If y is also an unbound type parameter, we will end // up here again with x and y swapped, so we don't // need to take care of that case separately. if cx := coreType(x); cx != nil { if traceInference { u.tracef("core %s ≡ %s", x, y) } // If y is a defined type, it may not match against cx which // is an underlying type (incl. int, string, etc.). Use assign // mode here so that the unifier automatically takes under(y) // if necessary. return u.nify(cx, y, assign, p) } } // x != y and there's nothing to do case nil: // avoid a crash in case of nil type default: panic(sprintf(nil, true, "u.nify(%s, %s, %d)", x, y, mode)) } return false } PK ! �ekA�+ �+ operand.gonu �[��� // Copyright 2012 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. // This file defines operands and associated operations. package types2 import ( "bytes" "cmd/compile/internal/syntax" "fmt" "go/constant" "go/token" . "internal/types/errors" ) // An operandMode specifies the (addressing) mode of an operand. type operandMode byte const ( invalid operandMode = iota // operand is invalid novalue // operand represents no value (result of a function call w/o result) builtin // operand is a built-in function typexpr // operand is a type constant_ // operand is a constant; the operand's typ is a Basic type variable // operand is an addressable variable mapindex // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment) value // operand is a computed value nilvalue // operand is the nil value commaok // like value, but operand may be used in a comma,ok expression commaerr // like commaok, but second value is error, not boolean cgofunc // operand is a cgo function ) var operandModeString = [...]string{ invalid: "invalid operand", novalue: "no value", builtin: "built-in", typexpr: "type", constant_: "constant", variable: "variable", mapindex: "map index expression", value: "value", nilvalue: "nil", commaok: "comma, ok expression", commaerr: "comma, error expression", cgofunc: "cgo function", } // An operand represents an intermediate value during type checking. // Operands have an (addressing) mode, the expression evaluating to // the operand, the operand's type, a value for constants, and an id // for built-in functions. // The zero value of operand is a ready to use invalid operand. type operand struct { mode operandMode expr syntax.Expr typ Type val constant.Value id builtinId } // Pos returns the position of the expression corresponding to x. // If x is invalid the position is nopos. func (x *operand) Pos() syntax.Pos { // x.expr may not be set if x is invalid if x.expr == nil { return nopos } return x.expr.Pos() } // Operand string formats // (not all "untyped" cases can appear due to the type system, // but they fall out naturally here) // // mode format // // invalid <expr> ( <mode> ) // novalue <expr> ( <mode> ) // builtin <expr> ( <mode> ) // typexpr <expr> ( <mode> ) // // constant <expr> (<untyped kind> <mode> ) // constant <expr> ( <mode> of type <typ>) // constant <expr> (<untyped kind> <mode> <val> ) // constant <expr> ( <mode> <val> of type <typ>) // // variable <expr> (<untyped kind> <mode> ) // variable <expr> ( <mode> of type <typ>) // // mapindex <expr> (<untyped kind> <mode> ) // mapindex <expr> ( <mode> of type <typ>) // // value <expr> (<untyped kind> <mode> ) // value <expr> ( <mode> of type <typ>) // // nilvalue untyped nil // nilvalue nil ( of type <typ>) // // commaok <expr> (<untyped kind> <mode> ) // commaok <expr> ( <mode> of type <typ>) // // commaerr <expr> (<untyped kind> <mode> ) // commaerr <expr> ( <mode> of type <typ>) // // cgofunc <expr> (<untyped kind> <mode> ) // cgofunc <expr> ( <mode> of type <typ>) func operandString(x *operand, qf Qualifier) string { // special-case nil if x.mode == nilvalue { switch x.typ { case nil, Typ[Invalid]: return "nil (with invalid type)" case Typ[UntypedNil]: return "nil" default: return fmt.Sprintf("nil (of type %s)", TypeString(x.typ, qf)) } } var buf bytes.Buffer var expr string if x.expr != nil { expr = syntax.String(x.expr) } else { switch x.mode { case builtin: expr = predeclaredFuncs[x.id].name case typexpr: expr = TypeString(x.typ, qf) case constant_: expr = x.val.String() } } // <expr> ( if expr != "" { buf.WriteString(expr) buf.WriteString(" (") } // <untyped kind> hasType := false switch x.mode { case invalid, novalue, builtin, typexpr: // no type default: // should have a type, but be cautious (don't crash during printing) if x.typ != nil { if isUntyped(x.typ) { buf.WriteString(x.typ.(*Basic).name) buf.WriteByte(' ') break } hasType = true } } // <mode> buf.WriteString(operandModeString[x.mode]) // <val> if x.mode == constant_ { if s := x.val.String(); s != expr { buf.WriteByte(' ') buf.WriteString(s) } } // <typ> if hasType { if isValid(x.typ) { var intro string if isGeneric(x.typ) { intro = " of generic type " } else { intro = " of type " } buf.WriteString(intro) WriteType(&buf, x.typ, qf) if tpar, _ := x.typ.(*TypeParam); tpar != nil { buf.WriteString(" constrained by ") WriteType(&buf, tpar.bound, qf) // do not compute interface type sets here // If we have the type set and it's empty, say so for better error messages. if hasEmptyTypeset(tpar) { buf.WriteString(" with empty type set") } } } else { buf.WriteString(" with invalid type") } } // ) if expr != "" { buf.WriteByte(')') } return buf.String() } func (x *operand) String() string { return operandString(x, nil) } // setConst sets x to the untyped constant for literal lit. func (x *operand) setConst(k syntax.LitKind, lit string) { var kind BasicKind switch k { case syntax.IntLit: kind = UntypedInt case syntax.FloatLit: kind = UntypedFloat case syntax.ImagLit: kind = UntypedComplex case syntax.RuneLit: kind = UntypedRune case syntax.StringLit: kind = UntypedString default: unreachable() } val := constant.MakeFromLiteral(lit, kind2tok[k], 0) if val.Kind() == constant.Unknown { x.mode = invalid x.typ = Typ[Invalid] return } x.mode = constant_ x.typ = Typ[kind] x.val = val } // isNil reports whether x is the (untyped) nil value. func (x *operand) isNil() bool { return x.mode == nilvalue } // assignableTo reports whether x is assignable to a variable of type T. If the // result is false and a non-nil cause is provided, it may be set to a more // detailed explanation of the failure (result != ""). The returned error code // is only valid if the (first) result is false. The check parameter may be nil // if assignableTo is invoked through an exported API call, i.e., when all // methods have been type-checked. func (x *operand) assignableTo(check *Checker, T Type, cause *string) (bool, Code) { if x.mode == invalid || !isValid(T) { return true, 0 // avoid spurious errors } V := x.typ // x's type is identical to T if Identical(V, T) { return true, 0 } Vu := under(V) Tu := under(T) Vp, _ := V.(*TypeParam) Tp, _ := T.(*TypeParam) // x is an untyped value representable by a value of type T. if isUntyped(Vu) { assert(Vp == nil) if Tp != nil { // T is a type parameter: x is assignable to T if it is // representable by each specific type in the type set of T. return Tp.is(func(t *term) bool { if t == nil { return false } // A term may be a tilde term but the underlying // type of an untyped value doesn't change so we // don't need to do anything special. newType, _, _ := check.implicitTypeAndValue(x, t.typ) return newType != nil }), IncompatibleAssign } newType, _, _ := check.implicitTypeAndValue(x, T) return newType != nil, IncompatibleAssign } // Vu is typed // x's type V and T have identical underlying types // and at least one of V or T is not a named type // and neither V nor T is a type parameter. if Identical(Vu, Tu) && (!hasName(V) || !hasName(T)) && Vp == nil && Tp == nil { return true, 0 } // T is an interface type, but not a type parameter, and V implements T. // Also handle the case where T is a pointer to an interface so that we get // the Checker.implements error cause. if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) { if check.implements(x.Pos(), V, T, false, cause) { return true, 0 } // V doesn't implement T but V may still be assignable to T if V // is a type parameter; do not report an error in that case yet. if Vp == nil { return false, InvalidIfaceAssign } if cause != nil { *cause = "" } } // If V is an interface, check if a missing type assertion is the problem. if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { if check.implements(x.Pos(), T, V, false, nil) { // T implements V, so give hint about type assertion. if cause != nil { *cause = "need type assertion" } return false, IncompatibleAssign } } // x is a bidirectional channel value, T is a channel // type, x's type V and T have identical element types, // and at least one of V or T is not a named type. if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv { if Tc, ok := Tu.(*Chan); ok && Identical(Vc.elem, Tc.elem) { return !hasName(V) || !hasName(T), InvalidChanAssign } } // optimization: if we don't have type parameters, we're done if Vp == nil && Tp == nil { return false, IncompatibleAssign } errorf := func(format string, args ...interface{}) { if check != nil && cause != nil { msg := check.sprintf(format, args...) if *cause != "" { msg += "\n\t" + *cause } *cause = msg } } // x's type V is not a named type and T is a type parameter, and // x is assignable to each specific type in T's type set. if !hasName(V) && Tp != nil { ok := false code := IncompatibleAssign Tp.is(func(T *term) bool { if T == nil { return false // no specific types } ok, code = x.assignableTo(check, T.typ, cause) if !ok { errorf("cannot assign %s to %s (in %s)", x.typ, T.typ, Tp) return false } return true }) return ok, code } // x's type V is a type parameter and T is not a named type, // and values x' of each specific type in V's type set are // assignable to T. if Vp != nil && !hasName(T) { x := *x // don't clobber outer x ok := false code := IncompatibleAssign Vp.is(func(V *term) bool { if V == nil { return false // no specific types } x.typ = V.typ ok, code = x.assignableTo(check, T, cause) if !ok { errorf("cannot assign %s (in %s) to %s", V.typ, Vp, T) return false } return true }) return ok, code } return false, IncompatibleAssign } // kind2tok translates syntax.LitKinds into token.Tokens. var kind2tok = [...]token.Token{ syntax.IntLit: token.INT, syntax.FloatLit: token.FLOAT, syntax.ImagLit: token.IMAG, syntax.RuneLit: token.CHAR, syntax.StringLit: token.STRING, } PK ! �v v� � termlist_test.gonu �[��� // Copyright 2021 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 types2 import ( "strings" "testing" ) // maketl makes a term list from a string of the term list. func maketl(s string) termlist { s = strings.ReplaceAll(s, " ", "") names := strings.Split(s, "|") r := make(termlist, len(names)) for i, n := range names { r[i] = testTerm(n) } return r } func TestTermlistAll(t *testing.T) { if !allTermlist.isAll() { t.Errorf("allTermlist is not the set of all types") } } func TestTermlistString(t *testing.T) { for _, want := range []string{ "∅", "𝓤", "int", "~int", "myInt", "∅ | ∅", "𝓤 | 𝓤", "∅ | 𝓤 | int", "∅ | 𝓤 | int | myInt", } { if got := maketl(want).String(); got != want { t.Errorf("(%v).String() == %v", want, got) } } } func TestTermlistIsEmpty(t *testing.T) { for test, want := range map[string]bool{ "∅": true, "∅ | ∅": true, "∅ | ∅ | 𝓤": false, "∅ | ∅ | myInt": false, "𝓤": false, "𝓤 | int": false, "𝓤 | myInt | ∅": false, } { xl := maketl(test) got := xl.isEmpty() if got != want { t.Errorf("(%v).isEmpty() == %v; want %v", test, got, want) } } } func TestTermlistIsAll(t *testing.T) { for test, want := range map[string]bool{ "∅": false, "∅ | ∅": false, "int | ~string": false, "~int | myInt": false, "∅ | ∅ | 𝓤": true, "𝓤": true, "𝓤 | int": true, "myInt | 𝓤": true, } { xl := maketl(test) got := xl.isAll() if got != want { t.Errorf("(%v).isAll() == %v; want %v", test, got, want) } } } func TestTermlistNorm(t *testing.T) { for _, test := range []struct { xl, want string }{ {"∅", "∅"}, {"∅ | ∅", "∅"}, {"∅ | int", "int"}, {"∅ | myInt", "myInt"}, {"𝓤 | int", "𝓤"}, {"𝓤 | myInt", "𝓤"}, {"int | myInt", "int | myInt"}, {"~int | int", "~int"}, {"~int | myInt", "~int"}, {"int | ~string | int", "int | ~string"}, {"~int | string | 𝓤 | ~string | int", "𝓤"}, {"~int | string | myInt | ~string | int", "~int | ~string"}, } { xl := maketl(test.xl) got := maketl(test.xl).norm() if got.String() != test.want { t.Errorf("(%v).norm() = %v; want %v", xl, got, test.want) } } } func TestTermlistUnion(t *testing.T) { for _, test := range []struct { xl, yl, want string }{ {"∅", "∅", "∅"}, {"∅", "𝓤", "𝓤"}, {"∅", "int", "int"}, {"𝓤", "~int", "𝓤"}, {"int", "~int", "~int"}, {"int", "string", "int | string"}, {"int", "myInt", "int | myInt"}, {"~int", "myInt", "~int"}, {"int | string", "~string", "int | ~string"}, {"~int | string", "~string | int", "~int | ~string"}, {"~int | string | ∅", "~string | int", "~int | ~string"}, {"~int | myInt | ∅", "~string | int", "~int | ~string"}, {"~int | string | 𝓤", "~string | int", "𝓤"}, {"~int | string | myInt", "~string | int", "~int | ~string"}, } { xl := maketl(test.xl) yl := maketl(test.yl) got := xl.union(yl).String() if got != test.want { t.Errorf("(%v).union(%v) = %v; want %v", test.xl, test.yl, got, test.want) } } } func TestTermlistIntersect(t *testing.T) { for _, test := range []struct { xl, yl, want string }{ {"∅", "∅", "∅"}, {"∅", "𝓤", "∅"}, {"∅", "int", "∅"}, {"∅", "myInt", "∅"}, {"𝓤", "~int", "~int"}, {"𝓤", "myInt", "myInt"}, {"int", "~int", "int"}, {"int", "string", "∅"}, {"int", "myInt", "∅"}, {"~int", "myInt", "myInt"}, {"int | string", "~string", "string"}, {"~int | string", "~string | int", "int | string"}, {"~int | string | ∅", "~string | int", "int | string"}, {"~int | myInt | ∅", "~string | int", "int"}, {"~int | string | 𝓤", "~string | int", "int | ~string"}, {"~int | string | myInt", "~string | int", "int | string"}, } { xl := maketl(test.xl) yl := maketl(test.yl) got := xl.intersect(yl).String() if got != test.want { t.Errorf("(%v).intersect(%v) = %v; want %v", test.xl, test.yl, got, test.want) } } } func TestTermlistEqual(t *testing.T) { for _, test := range []struct { xl, yl string want bool }{ {"∅", "∅", true}, {"∅", "𝓤", false}, {"𝓤", "𝓤", true}, {"𝓤 | int", "𝓤", true}, {"𝓤 | int", "string | 𝓤", true}, {"𝓤 | myInt", "string | 𝓤", true}, {"int | ~string", "string | int", false}, {"~int | string", "string | myInt", false}, {"int | ~string | ∅", "string | int | ~string", true}, } { xl := maketl(test.xl) yl := maketl(test.yl) got := xl.equal(yl) if got != test.want { t.Errorf("(%v).equal(%v) = %v; want %v", test.xl, test.yl, got, test.want) } } } func TestTermlistIncludes(t *testing.T) { for _, test := range []struct { xl, typ string want bool }{ {"∅", "int", false}, {"𝓤", "int", true}, {"~int", "int", true}, {"int", "string", false}, {"~int", "string", false}, {"~int", "myInt", true}, {"int | string", "string", true}, {"~int | string", "int", true}, {"~int | string", "myInt", true}, {"~int | myInt | ∅", "myInt", true}, {"myInt | ∅ | 𝓤", "int", true}, } { xl := maketl(test.xl) yl := testTerm(test.typ).typ got := xl.includes(yl) if got != test.want { t.Errorf("(%v).includes(%v) = %v; want %v", test.xl, yl, got, test.want) } } } func TestTermlistSupersetOf(t *testing.T) { for _, test := range []struct { xl, typ string want bool }{ {"∅", "∅", true}, {"∅", "𝓤", false}, {"∅", "int", false}, {"𝓤", "∅", true}, {"𝓤", "𝓤", true}, {"𝓤", "int", true}, {"𝓤", "~int", true}, {"𝓤", "myInt", true}, {"~int", "int", true}, {"~int", "~int", true}, {"~int", "myInt", true}, {"int", "~int", false}, {"myInt", "~int", false}, {"int", "string", false}, {"~int", "string", false}, {"int | string", "string", true}, {"int | string", "~string", false}, {"~int | string", "int", true}, {"~int | string", "myInt", true}, {"~int | string | ∅", "string", true}, {"~string | ∅ | 𝓤", "myInt", true}, } { xl := maketl(test.xl) y := testTerm(test.typ) got := xl.supersetOf(y) if got != test.want { t.Errorf("(%v).supersetOf(%v) = %v; want %v", test.xl, y, got, test.want) } } } func TestTermlistSubsetOf(t *testing.T) { for _, test := range []struct { xl, yl string want bool }{ {"∅", "∅", true}, {"∅", "𝓤", true}, {"𝓤", "∅", false}, {"𝓤", "𝓤", true}, {"int", "int | string", true}, {"~int", "int | string", false}, {"~int", "myInt | string", false}, {"myInt", "~int | string", true}, {"~int", "string | string | int | ~int", true}, {"myInt", "string | string | ~int", true}, {"int | string", "string", false}, {"int | string", "string | int", true}, {"int | ~string", "string | int", false}, {"myInt | ~string", "string | int | 𝓤", true}, {"int | ~string", "string | int | ∅ | string", false}, {"int | myInt", "string | ~int | ∅ | string", true}, } { xl := maketl(test.xl) yl := maketl(test.yl) got := xl.subsetOf(yl) if got != test.want { t.Errorf("(%v).subsetOf(%v) = %v; want %v", test.xl, test.yl, got, test.want) } } } PK ! I?�� � tuple.gonu �[��� // Copyright 2011 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 types2 // A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple. // Tuples are used as components of signatures and to represent the type of multiple // assignments; they are not first class types of Go. type Tuple struct { vars []*Var } // NewTuple returns a new tuple for the given variables. func NewTuple(x ...*Var) *Tuple { if len(x) > 0 { return &Tuple{vars: x} } return nil } // Len returns the number variables of tuple t. func (t *Tuple) Len() int { if t != nil { return len(t.vars) } return 0 } // At returns the i'th variable of tuple t. func (t *Tuple) At(i int) *Var { return t.vars[i] } func (t *Tuple) Underlying() Type { return t } func (t *Tuple) String() string { return TypeString(t, nil) } PK ! F�nX�� �� call.gonu �[��� // Copyright 2013 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. // This file implements typechecking of call and selector expressions. package types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" "strings" "unicode" ) // funcInst type-checks a function instantiation. // The incoming x must be a generic function. // If inst != nil, it provides some or all of the type arguments (inst.Index). // If target != nil, it may be used to infer missing type arguments of x, if any. // At least one of T or inst must be provided. // // There are two modes of operation: // // 1. If infer == true, funcInst infers missing type arguments as needed and // instantiates the function x. The returned results are nil. // // 2. If infer == false and inst provides all type arguments, funcInst // instantiates the function x. The returned results are nil. // If inst doesn't provide enough type arguments, funcInst returns the // available arguments and the corresponding expression list; x remains // unchanged. // // If an error (other than a version error) occurs in any case, it is reported // and x.mode is set to invalid. func (check *Checker) funcInst(T *target, pos syntax.Pos, x *operand, inst *syntax.IndexExpr, infer bool) ([]Type, []syntax.Expr) { assert(T != nil || inst != nil) var instErrPos poser if inst != nil { instErrPos = inst.Pos() } else { instErrPos = pos } versionErr := !check.verifyVersionf(instErrPos, go1_18, "function instantiation") // targs and xlist are the type arguments and corresponding type expressions, or nil. var targs []Type var xlist []syntax.Expr if inst != nil { xlist = syntax.UnpackListExpr(inst.Index) targs = check.typeList(xlist) if targs == nil { x.mode = invalid x.expr = inst return nil, nil } assert(len(targs) == len(xlist)) } // Check the number of type arguments (got) vs number of type parameters (want). // Note that x is a function value, not a type expression, so we don't need to // call under below. sig := x.typ.(*Signature) got, want := len(targs), sig.TypeParams().Len() if got > want { // Providing too many type arguments is always an error. check.errorf(xlist[got-1], WrongTypeArgCount, "got %d type arguments but want %d", got, want) x.mode = invalid x.expr = inst return nil, nil } if got < want { if !infer { return targs, xlist } // If the uninstantiated or partially instantiated function x is used in // an assignment (tsig != nil), infer missing type arguments by treating // the assignment // // var tvar tsig = x // // like a call g(tvar) of the synthetic generic function g // // func g[type_parameters_of_x](func_type_of_x) // var args []*operand var params []*Var var reverse bool if T != nil && sig.tparams != nil { if !versionErr && !check.allowVersion(check.pkg, instErrPos, go1_21) { if inst != nil { check.versionErrorf(instErrPos, go1_21, "partially instantiated function in assignment") } else { check.versionErrorf(instErrPos, go1_21, "implicitly instantiated function in assignment") } } gsig := NewSignatureType(nil, nil, nil, sig.params, sig.results, sig.variadic) params = []*Var{NewVar(x.Pos(), check.pkg, "", gsig)} // The type of the argument operand is tsig, which is the type of the LHS in an assignment // or the result type in a return statement. Create a pseudo-expression for that operand // that makes sense when reported in error messages from infer, below. expr := syntax.NewName(x.Pos(), T.desc) args = []*operand{{mode: value, expr: expr, typ: T.sig}} reverse = true } // Rename type parameters to avoid problems with recursive instantiations. // Note that NewTuple(params...) below is (*Tuple)(nil) if len(params) == 0, as desired. tparams, params2 := check.renameTParams(pos, sig.TypeParams().list(), NewTuple(params...)) targs = check.infer(pos, tparams, targs, params2.(*Tuple), args, reverse) if targs == nil { // error was already reported x.mode = invalid x.expr = inst return nil, nil } got = len(targs) } assert(got == want) // instantiate function signature expr := x.expr // if we don't have an index expression, keep the existing expression of x if inst != nil { expr = inst } sig = check.instantiateSignature(x.Pos(), expr, sig, targs, xlist) x.typ = sig x.mode = value x.expr = expr return nil, nil } func (check *Checker) instantiateSignature(pos syntax.Pos, expr syntax.Expr, typ *Signature, targs []Type, xlist []syntax.Expr) (res *Signature) { assert(check != nil) assert(len(targs) == typ.TypeParams().Len()) if check.conf.Trace { check.trace(pos, "-- instantiating signature %s with %s", typ, targs) check.indent++ defer func() { check.indent-- check.trace(pos, "=> %s (under = %s)", res, res.Underlying()) }() } inst := check.instance(pos, typ, targs, nil, check.context()).(*Signature) assert(inst.TypeParams().Len() == 0) // signature is not generic anymore check.recordInstance(expr, targs, inst) assert(len(xlist) <= len(targs)) // verify instantiation lazily (was go.dev/issue/50450) check.later(func() { tparams := typ.TypeParams().list() if i, err := check.verify(pos, tparams, targs, check.context()); err != nil { // best position for error reporting pos := pos if i < len(xlist) { pos = syntax.StartPos(xlist[i]) } check.softErrorf(pos, InvalidTypeArg, "%s", err) } else { check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist) } }).describef(pos, "verify instantiation") return inst } func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind { var inst *syntax.IndexExpr // function instantiation, if any if iexpr, _ := call.Fun.(*syntax.IndexExpr); iexpr != nil { if check.indexExpr(x, iexpr) { // Delay function instantiation to argument checking, // where we combine type and value arguments for type // inference. assert(x.mode == value) inst = iexpr } x.expr = iexpr check.record(x) } else { check.exprOrType(x, call.Fun, true) } // x.typ may be generic switch x.mode { case invalid: check.use(call.ArgList...) x.expr = call return statement case typexpr: // conversion check.nonGeneric(nil, x) if x.mode == invalid { return conversion } T := x.typ x.mode = invalid switch n := len(call.ArgList); n { case 0: check.errorf(call, WrongArgCount, "missing argument in conversion to %s", T) case 1: check.expr(nil, x, call.ArgList[0]) if x.mode != invalid { if t, _ := under(T).(*Interface); t != nil && !isTypeParam(T) { if !t.IsMethodSet() { check.errorf(call, MisplacedConstraintIface, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T) break } } if call.HasDots { check.errorf(call.ArgList[0], BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T) break } check.conversion(x, T) } default: check.use(call.ArgList...) check.errorf(call.ArgList[n-1], WrongArgCount, "too many arguments in conversion to %s", T) } x.expr = call return conversion case builtin: // no need to check for non-genericity here id := x.id if !check.builtin(x, call, id) { x.mode = invalid } x.expr = call // a non-constant result implies a function call if x.mode != invalid && x.mode != constant_ { check.hasCallOrRecv = true } return predeclaredFuncs[id].kind } // ordinary function/method call // signature may be generic cgocall := x.mode == cgofunc // a type parameter may be "called" if all types have the same signature sig, _ := coreType(x.typ).(*Signature) if sig == nil { check.errorf(x, InvalidCall, invalidOp+"cannot call non-function %s", x) x.mode = invalid x.expr = call return statement } // Capture wasGeneric before sig is potentially instantiated below. wasGeneric := sig.TypeParams().Len() > 0 // evaluate type arguments, if any var xlist []syntax.Expr var targs []Type if inst != nil { xlist = syntax.UnpackListExpr(inst.Index) targs = check.typeList(xlist) if targs == nil { check.use(call.ArgList...) x.mode = invalid x.expr = call return statement } assert(len(targs) == len(xlist)) // check number of type arguments (got) vs number of type parameters (want) got, want := len(targs), sig.TypeParams().Len() if got > want { check.errorf(xlist[want], WrongTypeArgCount, "got %d type arguments but want %d", got, want) check.use(call.ArgList...) x.mode = invalid x.expr = call return statement } // If sig is generic and all type arguments are provided, preempt function // argument type inference by explicitly instantiating the signature. This // ensures that we record accurate type information for sig, even if there // is an error checking its arguments (for example, if an incorrect number // of arguments is supplied). if got == want && want > 0 { check.verifyVersionf(inst, go1_18, "function instantiation") sig = check.instantiateSignature(inst.Pos(), inst, sig, targs, xlist) // targs have been consumed; proceed with checking arguments of the // non-generic signature. targs = nil xlist = nil } } // evaluate arguments args, atargs, atxlist := check.genericExprList(call.ArgList) sig = check.arguments(call, sig, targs, xlist, args, atargs, atxlist) if wasGeneric && sig.TypeParams().Len() == 0 { // update the recorded type of call.Fun to its instantiated type check.recordTypeAndValue(call.Fun, value, sig, nil) } // determine result switch sig.results.Len() { case 0: x.mode = novalue case 1: if cgocall { x.mode = commaerr } else { x.mode = value } x.typ = sig.results.vars[0].typ // unpack tuple default: x.mode = value x.typ = sig.results } x.expr = call check.hasCallOrRecv = true // if type inference failed, a parameterized result must be invalidated // (operands cannot have a parameterized type) if x.mode == value && sig.TypeParams().Len() > 0 && isParameterized(sig.TypeParams().list(), x.typ) { x.mode = invalid } return statement } // exprList evaluates a list of expressions and returns the corresponding operands. // A single-element expression list may evaluate to multiple operands. func (check *Checker) exprList(elist []syntax.Expr) (xlist []*operand) { if n := len(elist); n == 1 { xlist, _ = check.multiExpr(elist[0], false) } else if n > 1 { // multiple (possibly invalid) values xlist = make([]*operand, n) for i, e := range elist { var x operand check.expr(nil, &x, e) xlist[i] = &x } } return } // genericExprList is like exprList but result operands may be uninstantiated or partially // instantiated generic functions (where constraint information is insufficient to infer // the missing type arguments) for Go 1.21 and later. // For each non-generic or uninstantiated generic operand, the corresponding targsList and // xlistList elements do not exist (targsList and xlistList are nil) or the elements are nil. // For each partially instantiated generic function operand, the corresponding targsList and // xlistList elements are the operand's partial type arguments and type expression lists. func (check *Checker) genericExprList(elist []syntax.Expr) (resList []*operand, targsList [][]Type, xlistList [][]syntax.Expr) { if debug { defer func() { // targsList and xlistList must have matching lengths assert(len(targsList) == len(xlistList)) // type arguments must only exist for partially instantiated functions for i, x := range resList { if i < len(targsList) { if n := len(targsList[i]); n > 0 { // x must be a partially instantiated function assert(n < x.typ.(*Signature).TypeParams().Len()) } } } }() } // Before Go 1.21, uninstantiated or partially instantiated argument functions are // nor permitted. Checker.funcInst must infer missing type arguments in that case. infer := true // for -lang < go1.21 n := len(elist) if n > 0 && check.allowVersion(check.pkg, elist[0], go1_21) { infer = false } if n == 1 { // single value (possibly a partially instantiated function), or a multi-valued expression e := elist[0] var x operand if inst, _ := e.(*syntax.IndexExpr); inst != nil && check.indexExpr(&x, inst) { // x is a generic function. targs, xlist := check.funcInst(nil, x.Pos(), &x, inst, infer) if targs != nil { // x was not instantiated: collect the (partial) type arguments. targsList = [][]Type{targs} xlistList = [][]syntax.Expr{xlist} // Update x.expr so that we can record the partially instantiated function. x.expr = inst } else { // x was instantiated: we must record it here because we didn't // use the usual expression evaluators. check.record(&x) } resList = []*operand{&x} } else { // x is not a function instantiation (it may still be a generic function). check.rawExpr(nil, &x, e, nil, true) check.exclude(&x, 1<<novalue|1<<builtin|1<<typexpr) if t, ok := x.typ.(*Tuple); ok && x.mode != invalid { // x is a function call returning multiple values; it cannot be generic. resList = make([]*operand, t.Len()) for i, v := range t.vars { resList[i] = &operand{mode: value, expr: e, typ: v.typ} } } else { // x is exactly one value (possibly invalid or uninstantiated generic function). resList = []*operand{&x} } } } else if n > 1 { // multiple values resList = make([]*operand, n) targsList = make([][]Type, n) xlistList = make([][]syntax.Expr, n) for i, e := range elist { var x operand if inst, _ := e.(*syntax.IndexExpr); inst != nil && check.indexExpr(&x, inst) { // x is a generic function. targs, xlist := check.funcInst(nil, x.Pos(), &x, inst, infer) if targs != nil { // x was not instantiated: collect the (partial) type arguments. targsList[i] = targs xlistList[i] = xlist // Update x.expr so that we can record the partially instantiated function. x.expr = inst } else { // x was instantiated: we must record it here because we didn't // use the usual expression evaluators. check.record(&x) } } else { // x is exactly one value (possibly invalid or uninstantiated generic function). check.genericExpr(&x, e) } resList[i] = &x } } return } // arguments type-checks arguments passed to a function call with the given signature. // The function and its arguments may be generic, and possibly partially instantiated. // targs and xlist are the function's type arguments (and corresponding expressions). // args are the function arguments. If an argument args[i] is a partially instantiated // generic function, atargs[i] and atxlist[i] are the corresponding type arguments // (and corresponding expressions). // If the callee is variadic, arguments adjusts its signature to match the provided // arguments. The type parameters and arguments of the callee and all its arguments // are used together to infer any missing type arguments, and the callee and argument // functions are instantiated as necessary. // The result signature is the (possibly adjusted and instantiated) function signature. // If an error occurred, the result signature is the incoming sig. func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []Type, xlist []syntax.Expr, args []*operand, atargs [][]Type, atxlist [][]syntax.Expr) (rsig *Signature) { rsig = sig // Function call argument/parameter count requirements // // | standard call | dotdotdot call | // --------------+------------------+----------------+ // standard func | nargs == npars | invalid | // --------------+------------------+----------------+ // variadic func | nargs >= npars-1 | nargs == npars | // --------------+------------------+----------------+ nargs := len(args) npars := sig.params.Len() ddd := call.HasDots // set up parameters sigParams := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!) adjusted := false // indicates if sigParams is different from sig.params if sig.variadic { if ddd { // variadic_func(a, b, c...) if len(call.ArgList) == 1 && nargs > 1 { // f()... is not permitted if f() is multi-valued //check.errorf(call.Ellipsis, "cannot use ... with %d-valued %s", nargs, call.ArgList[0]) check.errorf(call, InvalidDotDotDot, "cannot use ... with %d-valued %s", nargs, call.ArgList[0]) return } } else { // variadic_func(a, b, c) if nargs >= npars-1 { // Create custom parameters for arguments: keep // the first npars-1 parameters and add one for // each argument mapping to the ... parameter. vars := make([]*Var, npars-1) // npars > 0 for variadic functions copy(vars, sig.params.vars) last := sig.params.vars[npars-1] typ := last.typ.(*Slice).elem for len(vars) < nargs { vars = append(vars, NewParam(last.pos, last.pkg, last.name, typ)) } sigParams = NewTuple(vars...) // possibly nil! adjusted = true npars = nargs } else { // nargs < npars-1 npars-- // for correct error message below } } } else { if ddd { // standard_func(a, b, c...) //check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", call.Fun) check.errorf(call, NonVariadicDotDotDot, "cannot use ... in call to non-variadic %s", call.Fun) return } // standard_func(a, b, c) } // check argument count if nargs != npars { var at poser = call qualifier := "not enough" if nargs > npars { at = args[npars].expr // report at first extra argument qualifier = "too many" } else if nargs > 0 { at = args[nargs-1].expr // report at last argument } // take care of empty parameter lists represented by nil tuples var params []*Var if sig.params != nil { params = sig.params.vars } var err error_ err.code = WrongArgCount err.errorf(at, "%s arguments in call to %s", qualifier, call.Fun) err.errorf(nopos, "have %s", check.typesSummary(operandTypes(args), false)) err.errorf(nopos, "want %s", check.typesSummary(varTypes(params), sig.variadic)) check.report(&err) return } // collect type parameters of callee and generic function arguments var tparams []*TypeParam // collect type parameters of callee n := sig.TypeParams().Len() if n > 0 { if !check.allowVersion(check.pkg, call.Pos(), go1_18) { if iexpr, _ := call.Fun.(*syntax.IndexExpr); iexpr != nil { check.versionErrorf(iexpr, go1_18, "function instantiation") } else { check.versionErrorf(call, go1_18, "implicit function instantiation") } } // rename type parameters to avoid problems with recursive calls var tmp Type tparams, tmp = check.renameTParams(call.Pos(), sig.TypeParams().list(), sigParams) sigParams = tmp.(*Tuple) // make sure targs and tparams have the same length for len(targs) < len(tparams) { targs = append(targs, nil) } } assert(len(tparams) == len(targs)) // collect type parameters from generic function arguments var genericArgs []int // indices of generic function arguments if enableReverseTypeInference { for i, arg := range args { // generic arguments cannot have a defined (*Named) type - no need for underlying type below if asig, _ := arg.typ.(*Signature); asig != nil && asig.TypeParams().Len() > 0 { // The argument type is a generic function signature. This type is // pointer-identical with (it's copied from) the type of the generic // function argument and thus the function object. // Before we change the type (type parameter renaming, below), make // a clone of it as otherwise we implicitly modify the object's type // (go.dev/issues/63260). asig = clone(asig) // Rename type parameters for cases like f(g, g); this gives each // generic function argument a unique type identity (go.dev/issues/59956). // TODO(gri) Consider only doing this if a function argument appears // multiple times, which is rare (possible optimization). atparams, tmp := check.renameTParams(call.Pos(), asig.TypeParams().list(), asig) asig = tmp.(*Signature) asig.tparams = &TypeParamList{atparams} // renameTParams doesn't touch associated type parameters arg.typ = asig // new type identity for the function argument tparams = append(tparams, atparams...) // add partial list of type arguments, if any if i < len(atargs) { targs = append(targs, atargs[i]...) } // make sure targs and tparams have the same length for len(targs) < len(tparams) { targs = append(targs, nil) } genericArgs = append(genericArgs, i) } } } assert(len(tparams) == len(targs)) // at the moment we only support implicit instantiations of argument functions _ = len(genericArgs) > 0 && check.verifyVersionf(args[genericArgs[0]], go1_21, "implicitly instantiated function as argument") // tparams holds the type parameters of the callee and generic function arguments, if any: // the first n type parameters belong to the callee, followed by mi type parameters for each // of the generic function arguments, where mi = args[i].typ.(*Signature).TypeParams().Len(). // infer missing type arguments of callee and function arguments if len(tparams) > 0 { targs = check.infer(call.Pos(), tparams, targs, sigParams, args, false) if targs == nil { // TODO(gri) If infer inferred the first targs[:n], consider instantiating // the call signature for better error messages/gopls behavior. // Perhaps instantiate as much as we can, also for arguments. // This will require changes to how infer returns its results. return // error already reported } // update result signature: instantiate if needed if n > 0 { rsig = check.instantiateSignature(call.Pos(), call.Fun, sig, targs[:n], xlist) // If the callee's parameter list was adjusted we need to update (instantiate) // it separately. Otherwise we can simply use the result signature's parameter // list. if adjusted { sigParams = check.subst(call.Pos(), sigParams, makeSubstMap(tparams[:n], targs[:n]), nil, check.context()).(*Tuple) } else { sigParams = rsig.params } } // compute argument signatures: instantiate if needed j := n for _, i := range genericArgs { arg := args[i] asig := arg.typ.(*Signature) k := j + asig.TypeParams().Len() // targs[j:k] are the inferred type arguments for asig arg.typ = check.instantiateSignature(call.Pos(), arg.expr, asig, targs[j:k], nil) // TODO(gri) provide xlist if possible (partial instantiations) check.record(arg) // record here because we didn't use the usual expr evaluators j = k } } // check arguments if len(args) > 0 { context := check.sprintf("argument to %s", call.Fun) for i, a := range args { check.assignment(a, sigParams.vars[i].typ, context) } } return } var cgoPrefixes = [...]string{ "_Ciconst_", "_Cfconst_", "_Csconst_", "_Ctype_", "_Cvar_", // actually a pointer to the var "_Cfpvar_fp_", "_Cfunc_", "_Cmacro_", // function to evaluate the expanded expression } func (check *Checker) selector(x *operand, e *syntax.SelectorExpr, def *TypeName, wantType bool) { // these must be declared before the "goto Error" statements var ( obj Object index []int indirect bool ) sel := e.Sel.Value // If the identifier refers to a package, handle everything here // so we don't need a "package" mode for operands: package names // can only appear in qualified identifiers which are mapped to // selector expressions. if ident, ok := e.X.(*syntax.Name); ok { obj := check.lookup(ident.Value) if pname, _ := obj.(*PkgName); pname != nil { assert(pname.pkg == check.pkg) check.recordUse(ident, pname) pname.used = true pkg := pname.imported var exp Object funcMode := value if pkg.cgo { // cgo special cases C.malloc: it's // rewritten to _CMalloc and does not // support two-result calls. if sel == "malloc" { sel = "_CMalloc" } else { funcMode = cgofunc } for _, prefix := range cgoPrefixes { // cgo objects are part of the current package (in file // _cgo_gotypes.go). Use regular lookup. _, exp = check.scope.LookupParent(prefix+sel, check.pos) if exp != nil { break } } if exp == nil { check.errorf(e.Sel, UndeclaredImportedName, "undefined: %s", syntax.Expr(e)) // cast to syntax.Expr to silence vet goto Error } check.objDecl(exp, nil) } else { exp = pkg.scope.Lookup(sel) if exp == nil { if !pkg.fake { check.errorf(e.Sel, UndeclaredImportedName, "undefined: %s", syntax.Expr(e)) } goto Error } if !exp.Exported() { check.errorf(e.Sel, UnexportedName, "%s not exported by package %s", sel, pkg.name) // ok to continue } } check.recordUse(e.Sel, exp) // Simplified version of the code for *syntax.Names: // - imported objects are always fully initialized switch exp := exp.(type) { case *Const: assert(exp.Val() != nil) x.mode = constant_ x.typ = exp.typ x.val = exp.val case *TypeName: x.mode = typexpr x.typ = exp.typ case *Var: x.mode = variable x.typ = exp.typ if pkg.cgo && strings.HasPrefix(exp.name, "_Cvar_") { x.typ = x.typ.(*Pointer).base } case *Func: x.mode = funcMode x.typ = exp.typ if pkg.cgo && strings.HasPrefix(exp.name, "_Cmacro_") { x.mode = value x.typ = x.typ.(*Signature).results.vars[0].typ } case *Builtin: x.mode = builtin x.typ = exp.typ x.id = exp.id default: check.dump("%v: unexpected object %v", atPos(e.Sel), exp) unreachable() } x.expr = e return } } check.exprOrType(x, e.X, false) switch x.mode { case typexpr: // don't crash for "type T T.x" (was go.dev/issue/51509) if def != nil && def.typ == x.typ { check.cycleError([]Object{def}) goto Error } case builtin: check.errorf(e.Pos(), UncalledBuiltin, "cannot select on %s", x) goto Error case invalid: goto Error } // Avoid crashing when checking an invalid selector in a method declaration // (i.e., where def is not set): // // type S[T any] struct{} // type V = S[any] // func (fs *S[T]) M(x V.M) {} // // All codepaths below return a non-type expression. If we get here while // expecting a type expression, it is an error. // // See go.dev/issue/57522 for more details. // // TODO(rfindley): We should do better by refusing to check selectors in all cases where // x.typ is incomplete. if wantType { check.errorf(e.Sel, NotAType, "%s is not a type", syntax.Expr(e)) goto Error } obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel) if obj == nil { // Don't report another error if the underlying type was invalid (go.dev/issue/49541). if !isValid(under(x.typ)) { goto Error } if index != nil { // TODO(gri) should provide actual type where the conflict happens check.errorf(e.Sel, AmbiguousSelector, "ambiguous selector %s.%s", x.expr, sel) goto Error } if indirect { if x.mode == typexpr { check.errorf(e.Sel, InvalidMethodExpr, "invalid method expression %s.%s (needs pointer receiver (*%s).%s)", x.typ, sel, x.typ, sel) } else { check.errorf(e.Sel, InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ) } goto Error } var why string if isInterfacePtr(x.typ) { why = check.interfacePtrError(x.typ) } else { why = check.sprintf("type %s has no field or method %s", x.typ, sel) // Check if capitalization of sel matters and provide better error message in that case. // TODO(gri) This code only looks at the first character but LookupFieldOrMethod has an // (internal) mechanism for case-insensitive lookup. Should use that instead. if len(sel) > 0 { var changeCase string if r := rune(sel[0]); unicode.IsUpper(r) { changeCase = string(unicode.ToLower(r)) + sel[1:] } else { changeCase = string(unicode.ToUpper(r)) + sel[1:] } if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { why += ", but does have " + changeCase } } } check.errorf(e.Sel, MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why) goto Error } // methods may not have a fully set up signature yet if m, _ := obj.(*Func); m != nil { check.objDecl(m, nil) } if x.mode == typexpr { // method expression m, _ := obj.(*Func) if m == nil { // TODO(gri) should check if capitalization of sel matters and provide better error message in that case check.errorf(e.Sel, MissingFieldOrMethod, "%s.%s undefined (type %s has no method %s)", x.expr, sel, x.typ, sel) goto Error } check.recordSelection(e, MethodExpr, x.typ, m, index, indirect) sig := m.typ.(*Signature) if sig.recv == nil { check.error(e, InvalidDeclCycle, "illegal cycle in method declaration") goto Error } // The receiver type becomes the type of the first function // argument of the method expression's function type. var params []*Var if sig.params != nil { params = sig.params.vars } // Be consistent about named/unnamed parameters. This is not needed // for type-checking, but the newly constructed signature may appear // in an error message and then have mixed named/unnamed parameters. // (An alternative would be to not print parameter names in errors, // but it's useful to see them; this is cheap and method expressions // are rare.) name := "" if len(params) > 0 && params[0].name != "" { // name needed name = sig.recv.name if name == "" { name = "_" } } params = append([]*Var{NewVar(sig.recv.pos, sig.recv.pkg, name, x.typ)}, params...) x.mode = value x.typ = &Signature{ tparams: sig.tparams, params: NewTuple(params...), results: sig.results, variadic: sig.variadic, } check.addDeclDep(m) } else { // regular selector switch obj := obj.(type) { case *Var: check.recordSelection(e, FieldVal, x.typ, obj, index, indirect) if x.mode == variable || indirect { x.mode = variable } else { x.mode = value } x.typ = obj.typ case *Func: // TODO(gri) If we needed to take into account the receiver's // addressability, should we report the type &(x.typ) instead? check.recordSelection(e, MethodVal, x.typ, obj, index, indirect) x.mode = value // remove receiver sig := *obj.typ.(*Signature) sig.recv = nil x.typ = &sig check.addDeclDep(obj) default: unreachable() } } // everything went well x.expr = e return Error: x.mode = invalid x.expr = e } // use type-checks each argument. // Useful to make sure expressions are evaluated // (and variables are "used") in the presence of // other errors. Arguments may be nil. // Reports if all arguments evaluated without error. func (check *Checker) use(args ...syntax.Expr) bool { return check.useN(args, false) } // useLHS is like use, but doesn't "use" top-level identifiers. // It should be called instead of use if the arguments are // expressions on the lhs of an assignment. func (check *Checker) useLHS(args ...syntax.Expr) bool { return check.useN(args, true) } func (check *Checker) useN(args []syntax.Expr, lhs bool) bool { ok := true for _, e := range args { if !check.use1(e, lhs) { ok = false } } return ok } func (check *Checker) use1(e syntax.Expr, lhs bool) bool { var x operand x.mode = value // anything but invalid switch n := syntax.Unparen(e).(type) { case nil: // nothing to do case *syntax.Name: // don't report an error evaluating blank if n.Value == "_" { break } // If the lhs is an identifier denoting a variable v, this assignment // is not a 'use' of v. Remember current value of v.used and restore // after evaluating the lhs via check.rawExpr. var v *Var var v_used bool if lhs { if _, obj := check.scope.LookupParent(n.Value, nopos); obj != nil { // It's ok to mark non-local variables, but ignore variables // from other packages to avoid potential race conditions with // dot-imported variables. if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg { v = w v_used = v.used } } } check.exprOrType(&x, n, true) if v != nil { v.used = v_used // restore v.used } case *syntax.ListExpr: return check.useN(n.ElemList, lhs) default: check.rawExpr(nil, &x, e, nil, true) } return x.mode != invalid } PK ! ��r.? .? typexpr.gonu �[��� // Copyright 2013 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. // This file implements type-checking of identifiers and type expressions. package types2 import ( "cmd/compile/internal/syntax" "fmt" "go/constant" . "internal/types/errors" "strings" ) // ident type-checks identifier e and initializes x with the value or type of e. // If an error occurred, x.mode is set to invalid. // For the meaning of def, see Checker.definedType, below. // If wantType is set, the identifier e is expected to denote a type. func (check *Checker) ident(x *operand, e *syntax.Name, def *TypeName, wantType bool) { x.mode = invalid x.expr = e // Note that we cannot use check.lookup here because the returned scope // may be different from obj.Parent(). See also Scope.LookupParent doc. scope, obj := check.scope.LookupParent(e.Value, check.pos) switch obj { case nil: if e.Value == "_" { // Blank identifiers are never declared, but the current identifier may // be a placeholder for a receiver type parameter. In this case we can // resolve its type and object from Checker.recvTParamMap. if tpar := check.recvTParamMap[e]; tpar != nil { x.mode = typexpr x.typ = tpar } else { check.error(e, InvalidBlank, "cannot use _ as value or type") } } else { check.errorf(e, UndeclaredName, "undefined: %s", e.Value) } return case universeAny, universeComparable: if !check.verifyVersionf(e, go1_18, "predeclared %s", e.Value) { return // avoid follow-on errors } } check.recordUse(e, obj) // Type-check the object. // Only call Checker.objDecl if the object doesn't have a type yet // (in which case we must actually determine it) or the object is a // TypeName and we also want a type (in which case we might detect // a cycle which needs to be reported). Otherwise we can skip the // call and avoid a possible cycle error in favor of the more // informative "not a type/value" error that this function's caller // will issue (see go.dev/issue/25790). typ := obj.Type() if _, gotType := obj.(*TypeName); typ == nil || gotType && wantType { check.objDecl(obj, def) typ = obj.Type() // type must have been assigned by Checker.objDecl } assert(typ != nil) // The object may have been dot-imported. // If so, mark the respective package as used. // (This code is only needed for dot-imports. Without them, // we only have to mark variables, see *Var case below). if pkgName := check.dotImportMap[dotImportKey{scope, obj.Name()}]; pkgName != nil { pkgName.used = true } switch obj := obj.(type) { case *PkgName: check.errorf(e, InvalidPkgUse, "use of package %s not in selector", obj.name) return case *Const: check.addDeclDep(obj) if !isValid(typ) { return } if obj == universeIota { if check.iota == nil { check.error(e, InvalidIota, "cannot use iota outside constant declaration") return } x.val = check.iota } else { x.val = obj.val } assert(x.val != nil) x.mode = constant_ case *TypeName: if !check.enableAlias && check.isBrokenAlias(obj) { check.errorf(e, InvalidDeclCycle, "invalid use of type alias %s in recursive type (see go.dev/issue/50729)", obj.name) return } x.mode = typexpr case *Var: // It's ok to mark non-local variables, but ignore variables // from other packages to avoid potential race conditions with // dot-imported variables. if obj.pkg == check.pkg { obj.used = true } check.addDeclDep(obj) if !isValid(typ) { return } x.mode = variable case *Func: check.addDeclDep(obj) x.mode = value case *Builtin: x.id = obj.id x.mode = builtin case *Nil: x.mode = nilvalue default: unreachable() } x.typ = typ } // typ type-checks the type expression e and returns its type, or Typ[Invalid]. // The type must not be an (uninstantiated) generic type. func (check *Checker) typ(e syntax.Expr) Type { return check.definedType(e, nil) } // varType type-checks the type expression e and returns its type, or Typ[Invalid]. // The type must not be an (uninstantiated) generic type and it must not be a // constraint interface. func (check *Checker) varType(e syntax.Expr) Type { typ := check.definedType(e, nil) check.validVarType(e, typ) return typ } // validVarType reports an error if typ is a constraint interface. // The expression e is used for error reporting, if any. func (check *Checker) validVarType(e syntax.Expr, typ Type) { // If we have a type parameter there's nothing to do. if isTypeParam(typ) { return } // We don't want to call under() or complete interfaces while we are in // the middle of type-checking parameter declarations that might belong // to interface methods. Delay this check to the end of type-checking. check.later(func() { if t, _ := under(typ).(*Interface); t != nil { pos := syntax.StartPos(e) tset := computeInterfaceTypeSet(check, pos, t) // TODO(gri) is this the correct position? if !tset.IsMethodSet() { if tset.comparable { check.softErrorf(pos, MisplacedConstraintIface, "cannot use type %s outside a type constraint: interface is (or embeds) comparable", typ) } else { check.softErrorf(pos, MisplacedConstraintIface, "cannot use type %s outside a type constraint: interface contains type constraints", typ) } } } }).describef(e, "check var type %s", typ) } // definedType is like typ but also accepts a type name def. // If def != nil, e is the type specification for the type named def, declared // in a type declaration, and def.typ.underlying will be set to the type of e // before any components of e are type-checked. func (check *Checker) definedType(e syntax.Expr, def *TypeName) Type { typ := check.typInternal(e, def) assert(isTyped(typ)) if isGeneric(typ) { check.errorf(e, WrongTypeArgCount, "cannot use generic type %s without instantiation", typ) typ = Typ[Invalid] } check.recordTypeAndValue(e, typexpr, typ, nil) return typ } // genericType is like typ but the type must be an (uninstantiated) generic // type. If cause is non-nil and the type expression was a valid type but not // generic, cause will be populated with a message describing the error. func (check *Checker) genericType(e syntax.Expr, cause *string) Type { typ := check.typInternal(e, nil) assert(isTyped(typ)) if isValid(typ) && !isGeneric(typ) { if cause != nil { *cause = check.sprintf("%s is not a generic type", typ) } typ = Typ[Invalid] } // TODO(gri) what is the correct call below? check.recordTypeAndValue(e, typexpr, typ, nil) return typ } // goTypeName returns the Go type name for typ and // removes any occurrences of "types2." from that name. func goTypeName(typ Type) string { return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types2.", "") } // typInternal drives type checking of types. // Must only be called by definedType or genericType. func (check *Checker) typInternal(e0 syntax.Expr, def *TypeName) (T Type) { if check.conf.Trace { check.trace(e0.Pos(), "-- type %s", e0) check.indent++ defer func() { check.indent-- var under Type if T != nil { // Calling under() here may lead to endless instantiations. // Test case: type T[P any] *T[P] under = safeUnderlying(T) } if T == under { check.trace(e0.Pos(), "=> %s // %s", T, goTypeName(T)) } else { check.trace(e0.Pos(), "=> %s (under = %s) // %s", T, under, goTypeName(T)) } }() } switch e := e0.(type) { case *syntax.BadExpr: // ignore - error reported before case *syntax.Name: var x operand check.ident(&x, e, def, true) switch x.mode { case typexpr: typ := x.typ setDefType(def, typ) return typ case invalid: // ignore - error reported before case novalue: check.errorf(&x, NotAType, "%s used as type", &x) default: check.errorf(&x, NotAType, "%s is not a type", &x) } case *syntax.SelectorExpr: var x operand check.selector(&x, e, def, true) switch x.mode { case typexpr: typ := x.typ setDefType(def, typ) return typ case invalid: // ignore - error reported before case novalue: check.errorf(&x, NotAType, "%s used as type", &x) default: check.errorf(&x, NotAType, "%s is not a type", &x) } case *syntax.IndexExpr: check.verifyVersionf(e, go1_18, "type instantiation") return check.instantiatedType(e.X, syntax.UnpackListExpr(e.Index), def) case *syntax.ParenExpr: // Generic types must be instantiated before they can be used in any form. // Consequently, generic types cannot be parenthesized. return check.definedType(e.X, def) case *syntax.ArrayType: typ := new(Array) setDefType(def, typ) if e.Len != nil { typ.len = check.arrayLength(e.Len) } else { // [...]array check.error(e, BadDotDotDotSyntax, "invalid use of [...] array (outside a composite literal)") typ.len = -1 } typ.elem = check.varType(e.Elem) if typ.len >= 0 { return typ } // report error if we encountered [...] case *syntax.SliceType: typ := new(Slice) setDefType(def, typ) typ.elem = check.varType(e.Elem) return typ case *syntax.DotsType: // dots are handled explicitly where they are legal // (array composite literals and parameter lists) check.error(e, InvalidDotDotDot, "invalid use of '...'") check.use(e.Elem) case *syntax.StructType: typ := new(Struct) setDefType(def, typ) check.structType(typ, e) return typ case *syntax.Operation: if e.Op == syntax.Mul && e.Y == nil { typ := new(Pointer) typ.base = Typ[Invalid] // avoid nil base in invalid recursive type declaration setDefType(def, typ) typ.base = check.varType(e.X) // If typ.base is invalid, it's unlikely that *base is particularly // useful - even a valid dereferenciation will lead to an invalid // type again, and in some cases we get unexpected follow-on errors // (e.g., go.dev/issue/49005). Return an invalid type instead. if !isValid(typ.base) { return Typ[Invalid] } return typ } check.errorf(e0, NotAType, "%s is not a type", e0) check.use(e0) case *syntax.FuncType: typ := new(Signature) setDefType(def, typ) check.funcType(typ, nil, nil, e) return typ case *syntax.InterfaceType: typ := check.newInterface() setDefType(def, typ) check.interfaceType(typ, e, def) return typ case *syntax.MapType: typ := new(Map) setDefType(def, typ) typ.key = check.varType(e.Key) typ.elem = check.varType(e.Value) // spec: "The comparison operators == and != must be fully defined // for operands of the key type; thus the key type must not be a // function, map, or slice." // // Delay this check because it requires fully setup types; // it is safe to continue in any case (was go.dev/issue/6667). check.later(func() { if !Comparable(typ.key) { var why string if isTypeParam(typ.key) { why = " (missing comparable constraint)" } check.errorf(e.Key, IncomparableMapKey, "invalid map key type %s%s", typ.key, why) } }).describef(e.Key, "check map key %s", typ.key) return typ case *syntax.ChanType: typ := new(Chan) setDefType(def, typ) dir := SendRecv switch e.Dir { case 0: // nothing to do case syntax.SendOnly: dir = SendOnly case syntax.RecvOnly: dir = RecvOnly default: check.errorf(e, InvalidSyntaxTree, "unknown channel direction %d", e.Dir) // ok to continue } typ.dir = dir typ.elem = check.varType(e.Elem) return typ default: check.errorf(e0, NotAType, "%s is not a type", e0) check.use(e0) } typ := Typ[Invalid] setDefType(def, typ) return typ } func setDefType(def *TypeName, typ Type) { if def != nil { switch t := def.typ.(type) { case *Alias: // t.fromRHS should always be set, either to an invalid type // in the beginning, or to typ in certain cyclic declarations. if t.fromRHS != Typ[Invalid] && t.fromRHS != typ { panic(sprintf(nil, true, "t.fromRHS = %s, typ = %s\n", t.fromRHS, typ)) } t.fromRHS = typ case *Basic: assert(t == Typ[Invalid]) case *Named: t.underlying = typ default: panic(fmt.Sprintf("unexpected type %T", t)) } } } func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def *TypeName) (res Type) { if check.conf.Trace { check.trace(x.Pos(), "-- instantiating type %s with %s", x, xlist) check.indent++ defer func() { check.indent-- // Don't format the underlying here. It will always be nil. check.trace(x.Pos(), "=> %s", res) }() } var cause string gtyp := check.genericType(x, &cause) if cause != "" { check.errorf(x, NotAGenericType, invalidOp+"%s%s (%s)", x, xlist, cause) } if !isValid(gtyp) { return gtyp // error already reported } orig := asNamed(gtyp) if orig == nil { panic(fmt.Sprintf("%v: cannot instantiate %v", x.Pos(), gtyp)) } // evaluate arguments targs := check.typeList(xlist) if targs == nil { setDefType(def, Typ[Invalid]) // avoid errors later due to lazy instantiation return Typ[Invalid] } // create the instance inst := asNamed(check.instance(x.Pos(), orig, targs, nil, check.context())) setDefType(def, inst) // orig.tparams may not be set up, so we need to do expansion later. check.later(func() { // This is an instance from the source, not from recursive substitution, // and so it must be resolved during type-checking so that we can report // errors. check.recordInstance(x, inst.TypeArgs().list(), inst) if check.validateTArgLen(x.Pos(), inst.obj.name, inst.TypeParams().Len(), inst.TypeArgs().Len()) { if i, err := check.verify(x.Pos(), inst.TypeParams().list(), inst.TypeArgs().list(), check.context()); err != nil { // best position for error reporting pos := x.Pos() if i < len(xlist) { pos = syntax.StartPos(xlist[i]) } check.softErrorf(pos, InvalidTypeArg, "%s", err) } else { check.mono.recordInstance(check.pkg, x.Pos(), inst.TypeParams().list(), inst.TypeArgs().list(), xlist) } } // TODO(rfindley): remove this call: we don't need to call validType here, // as cycles can only occur for types used inside a Named type declaration, // and so it suffices to call validType from declared types. check.validType(inst) }).describef(x, "resolve instance %s", inst) return inst } // arrayLength type-checks the array length expression e // and returns the constant length >= 0, or a value < 0 // to indicate an error (and thus an unknown length). func (check *Checker) arrayLength(e syntax.Expr) int64 { // If e is an identifier, the array declaration might be an // attempt at a parameterized type declaration with missing // constraint. Provide an error message that mentions array // length. if name, _ := e.(*syntax.Name); name != nil { obj := check.lookup(name.Value) if obj == nil { check.errorf(name, InvalidArrayLen, "undefined array length %s or missing type constraint", name.Value) return -1 } if _, ok := obj.(*Const); !ok { check.errorf(name, InvalidArrayLen, "invalid array length %s", name.Value) return -1 } } var x operand check.expr(nil, &x, e) if x.mode != constant_ { if x.mode != invalid { check.errorf(&x, InvalidArrayLen, "array length %s must be constant", &x) } return -1 } if isUntyped(x.typ) || isInteger(x.typ) { if val := constant.ToInt(x.val); val.Kind() == constant.Int { if representableConst(val, check, Typ[Int], nil) { if n, ok := constant.Int64Val(val); ok && n >= 0 { return n } } } } var msg string if isInteger(x.typ) { msg = "invalid array length %s" } else { msg = "array length %s must be integer" } check.errorf(&x, InvalidArrayLen, msg, &x) return -1 } // typeList provides the list of types corresponding to the incoming expression list. // If an error occurred, the result is nil, but all list elements were type-checked. func (check *Checker) typeList(list []syntax.Expr) []Type { res := make([]Type, len(list)) // res != nil even if len(list) == 0 for i, x := range list { t := check.varType(x) if !isValid(t) { res = nil } if res != nil { res[i] = t } } return res } PK ! �t�Vg Vg resolver.gonu �[��� // Copyright 2013 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 types2 import ( "cmd/compile/internal/syntax" "fmt" "go/constant" . "internal/types/errors" "sort" "strconv" "strings" "unicode" ) // A declInfo describes a package-level const, type, var, or func declaration. type declInfo struct { file *Scope // scope of file containing this declaration lhs []*Var // lhs of n:1 variable declarations, or nil vtyp syntax.Expr // type, or nil (for const and var declarations only) init syntax.Expr // init/orig expression, or nil (for const and var declarations only) inherited bool // if set, the init expression is inherited from a previous constant declaration tdecl *syntax.TypeDecl // type declaration, or nil fdecl *syntax.FuncDecl // func declaration, or nil // The deps field tracks initialization expression dependencies. deps map[Object]bool // lazily initialized } // hasInitializer reports whether the declared object has an initialization // expression or function body. func (d *declInfo) hasInitializer() bool { return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil } // addDep adds obj to the set of objects d's init expression depends on. func (d *declInfo) addDep(obj Object) { m := d.deps if m == nil { m = make(map[Object]bool) d.deps = m } m[obj] = true } // arity checks that the lhs and rhs of a const or var decl // have a matching number of names and initialization values. // If inherited is set, the initialization values are from // another (constant) declaration. func (check *Checker) arity(pos syntax.Pos, names []*syntax.Name, inits []syntax.Expr, constDecl, inherited bool) { l := len(names) r := len(inits) const code = WrongAssignCount switch { case l < r: n := inits[l] if inherited { check.errorf(pos, code, "extra init expr at %s", n.Pos()) } else { check.errorf(n, code, "extra init expr %s", n) } case l > r && (constDecl || r != 1): // if r == 1 it may be a multi-valued function and we can't say anything yet n := names[r] check.errorf(n, code, "missing init expr for %s", n.Value) } } func validatedImportPath(path string) (string, error) { s, err := strconv.Unquote(path) if err != nil { return "", err } if s == "" { return "", fmt.Errorf("empty string") } const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD" for _, r := range s { if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) { return s, fmt.Errorf("invalid character %#U", r) } } return s, nil } // declarePkgObj declares obj in the package scope, records its ident -> obj mapping, // and updates check.objMap. The object must not be a function or method. func (check *Checker) declarePkgObj(ident *syntax.Name, obj Object, d *declInfo) { assert(ident.Value == obj.Name()) // spec: "A package-scope or file-scope identifier with name init // may only be declared to be a function with this (func()) signature." if ident.Value == "init" { check.error(ident, InvalidInitDecl, "cannot declare init - must be func") return } // spec: "The main package must have package name main and declare // a function main that takes no arguments and returns no value." if ident.Value == "main" && check.pkg.name == "main" { check.error(ident, InvalidMainDecl, "cannot declare main - must be func") return } check.declare(check.pkg.scope, ident, obj, nopos) check.objMap[obj] = d obj.setOrder(uint32(len(check.objMap))) } // filename returns a filename suitable for debugging output. func (check *Checker) filename(fileNo int) string { file := check.files[fileNo] if pos := file.Pos(); pos.IsKnown() { // return check.fset.File(pos).Name() // TODO(gri) do we need the actual file name here? return pos.RelFilename() } return fmt.Sprintf("file[%d]", fileNo) } func (check *Checker) importPackage(pos syntax.Pos, path, dir string) *Package { // If we already have a package for the given (path, dir) // pair, use it instead of doing a full import. // Checker.impMap only caches packages that are marked Complete // or fake (dummy packages for failed imports). Incomplete but // non-fake packages do require an import to complete them. key := importKey{path, dir} imp := check.impMap[key] if imp != nil { return imp } // no package yet => import it if path == "C" && (check.conf.FakeImportC || check.conf.go115UsesCgo) { imp = NewPackage("C", "C") imp.fake = true // package scope is not populated imp.cgo = check.conf.go115UsesCgo } else { // ordinary import var err error if importer := check.conf.Importer; importer == nil { err = fmt.Errorf("Config.Importer not installed") } else if importerFrom, ok := importer.(ImporterFrom); ok { imp, err = importerFrom.ImportFrom(path, dir, 0) if imp == nil && err == nil { err = fmt.Errorf("Config.Importer.ImportFrom(%s, %s, 0) returned nil but no error", path, dir) } } else { imp, err = importer.Import(path) if imp == nil && err == nil { err = fmt.Errorf("Config.Importer.Import(%s) returned nil but no error", path) } } // make sure we have a valid package name // (errors here can only happen through manipulation of packages after creation) if err == nil && imp != nil && (imp.name == "_" || imp.name == "") { err = fmt.Errorf("invalid package name: %q", imp.name) imp = nil // create fake package below } if err != nil { check.errorf(pos, BrokenImport, "could not import %s (%s)", path, err) if imp == nil { // create a new fake package // come up with a sensible package name (heuristic) name := path if i := len(name); i > 0 && name[i-1] == '/' { name = name[:i-1] } if i := strings.LastIndex(name, "/"); i >= 0 { name = name[i+1:] } imp = NewPackage(path, name) } // continue to use the package as best as we can imp.fake = true // avoid follow-up lookup failures } } // package should be complete or marked fake, but be cautious if imp.complete || imp.fake { check.impMap[key] = imp // Once we've formatted an error message, keep the pkgPathMap // up-to-date on subsequent imports. It is used for package // qualification in error messages. if check.pkgPathMap != nil { check.markImports(imp) } return imp } // something went wrong (importer may have returned incomplete package without error) return nil } // collectObjects collects all file and package objects and inserts them // into their respective scopes. It also performs imports and associates // methods with receiver base type names. func (check *Checker) collectObjects() { pkg := check.pkg // pkgImports is the set of packages already imported by any package file seen // so far. Used to avoid duplicate entries in pkg.imports. Allocate and populate // it (pkg.imports may not be empty if we are checking test files incrementally). // Note that pkgImports is keyed by package (and thus package path), not by an // importKey value. Two different importKey values may map to the same package // which is why we cannot use the check.impMap here. var pkgImports = make(map[*Package]bool) for _, imp := range pkg.imports { pkgImports[imp] = true } type methodInfo struct { obj *Func // method ptr bool // true if pointer receiver recv *syntax.Name // receiver type name } var methods []methodInfo // collected methods with valid receivers and non-blank _ names var fileScopes []*Scope for fileNo, file := range check.files { // The package identifier denotes the current package, // but there is no corresponding package object. check.recordDef(file.PkgName, nil) fileScope := NewScope(pkg.scope, syntax.StartPos(file), syntax.EndPos(file), check.filename(fileNo)) fileScopes = append(fileScopes, fileScope) check.recordScope(file, fileScope) // determine file directory, necessary to resolve imports // FileName may be "" (typically for tests) in which case // we get "." as the directory which is what we would want. fileDir := dir(file.PkgName.Pos().RelFilename()) // TODO(gri) should this be filename? first := -1 // index of first ConstDecl in the current group, or -1 var last *syntax.ConstDecl // last ConstDecl with init expressions, or nil for index, decl := range file.DeclList { if _, ok := decl.(*syntax.ConstDecl); !ok { first = -1 // we're not in a constant declaration } switch s := decl.(type) { case *syntax.ImportDecl: // import package if s.Path == nil || s.Path.Bad { continue // error reported during parsing } path, err := validatedImportPath(s.Path.Value) if err != nil { check.errorf(s.Path, BadImportPath, "invalid import path (%s)", err) continue } imp := check.importPackage(s.Path.Pos(), path, fileDir) if imp == nil { continue } // local name overrides imported package name name := imp.name if s.LocalPkgName != nil { name = s.LocalPkgName.Value if path == "C" { // match 1.17 cmd/compile (not prescribed by spec) check.error(s.LocalPkgName, ImportCRenamed, `cannot rename import "C"`) continue } } if name == "init" { check.error(s, InvalidInitDecl, "cannot import package as init - init must be a func") continue } // add package to list of explicit imports // (this functionality is provided as a convenience // for clients; it is not needed for type-checking) if !pkgImports[imp] { pkgImports[imp] = true pkg.imports = append(pkg.imports, imp) } pkgName := NewPkgName(s.Pos(), pkg, name, imp) if s.LocalPkgName != nil { // in a dot-import, the dot represents the package check.recordDef(s.LocalPkgName, pkgName) } else { check.recordImplicit(s, pkgName) } if imp.fake { // match 1.17 cmd/compile (not prescribed by spec) pkgName.used = true } // add import to file scope check.imports = append(check.imports, pkgName) if name == "." { // dot-import if check.dotImportMap == nil { check.dotImportMap = make(map[dotImportKey]*PkgName) } // merge imported scope with file scope for name, obj := range imp.scope.elems { // Note: Avoid eager resolve(name, obj) here, so we only // resolve dot-imported objects as needed. // A package scope may contain non-exported objects, // do not import them! if isExported(name) { // declare dot-imported object // (Do not use check.declare because it modifies the object // via Object.setScopePos, which leads to a race condition; // the object may be imported into more than one file scope // concurrently. See go.dev/issue/32154.) if alt := fileScope.Lookup(name); alt != nil { var err error_ err.code = DuplicateDecl err.errorf(s.LocalPkgName, "%s redeclared in this block", alt.Name()) err.recordAltDecl(alt) check.report(&err) } else { fileScope.insert(name, obj) check.dotImportMap[dotImportKey{fileScope, name}] = pkgName } } } } else { // declare imported package object in file scope // (no need to provide s.LocalPkgName since we called check.recordDef earlier) check.declare(fileScope, nil, pkgName, nopos) } case *syntax.ConstDecl: // iota is the index of the current constDecl within the group if first < 0 || s.Group == nil || file.DeclList[index-1].(*syntax.ConstDecl).Group != s.Group { first = index last = nil } iota := constant.MakeInt64(int64(index - first)) // determine which initialization expressions to use inherited := true switch { case s.Type != nil || s.Values != nil: last = s inherited = false case last == nil: last = new(syntax.ConstDecl) // make sure last exists inherited = false } // declare all constants values := syntax.UnpackListExpr(last.Values) for i, name := range s.NameList { obj := NewConst(name.Pos(), pkg, name.Value, nil, iota) var init syntax.Expr if i < len(values) { init = values[i] } d := &declInfo{file: fileScope, vtyp: last.Type, init: init, inherited: inherited} check.declarePkgObj(name, obj, d) } // Constants must always have init values. check.arity(s.Pos(), s.NameList, values, true, inherited) case *syntax.VarDecl: lhs := make([]*Var, len(s.NameList)) // If there's exactly one rhs initializer, use // the same declInfo d1 for all lhs variables // so that each lhs variable depends on the same // rhs initializer (n:1 var declaration). var d1 *declInfo if _, ok := s.Values.(*syntax.ListExpr); !ok { // The lhs elements are only set up after the for loop below, // but that's ok because declarePkgObj only collects the declInfo // for a later phase. d1 = &declInfo{file: fileScope, lhs: lhs, vtyp: s.Type, init: s.Values} } // declare all variables values := syntax.UnpackListExpr(s.Values) for i, name := range s.NameList { obj := NewVar(name.Pos(), pkg, name.Value, nil) lhs[i] = obj d := d1 if d == nil { // individual assignments var init syntax.Expr if i < len(values) { init = values[i] } d = &declInfo{file: fileScope, vtyp: s.Type, init: init} } check.declarePkgObj(name, obj, d) } // If we have no type, we must have values. if s.Type == nil || values != nil { check.arity(s.Pos(), s.NameList, values, false, false) } case *syntax.TypeDecl: _ = len(s.TParamList) != 0 && check.verifyVersionf(s.TParamList[0], go1_18, "type parameter") obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Value, nil) check.declarePkgObj(s.Name, obj, &declInfo{file: fileScope, tdecl: s}) case *syntax.FuncDecl: name := s.Name.Value obj := NewFunc(s.Name.Pos(), pkg, name, nil) hasTParamError := false // avoid duplicate type parameter errors if s.Recv == nil { // regular function if name == "init" || name == "main" && pkg.name == "main" { code := InvalidInitDecl if name == "main" { code = InvalidMainDecl } if len(s.TParamList) != 0 { check.softErrorf(s.TParamList[0], code, "func %s must have no type parameters", name) hasTParamError = true } if t := s.Type; len(t.ParamList) != 0 || len(t.ResultList) != 0 { check.softErrorf(s.Name, code, "func %s must have no arguments and no return values", name) } } // don't declare init functions in the package scope - they are invisible if name == "init" { obj.parent = pkg.scope check.recordDef(s.Name, obj) // init functions must have a body if s.Body == nil { // TODO(gri) make this error message consistent with the others above check.softErrorf(obj.pos, MissingInitBody, "missing function body") } } else { check.declare(pkg.scope, s.Name, obj, nopos) } } else { // method // d.Recv != nil ptr, recv, _ := check.unpackRecv(s.Recv.Type, false) // Methods with invalid receiver cannot be associated to a type, and // methods with blank _ names are never found; no need to collect any // of them. They will still be type-checked with all the other functions. if recv != nil && name != "_" { methods = append(methods, methodInfo{obj, ptr, recv}) } check.recordDef(s.Name, obj) } _ = len(s.TParamList) != 0 && !hasTParamError && check.verifyVersionf(s.TParamList[0], go1_18, "type parameter") info := &declInfo{file: fileScope, fdecl: s} // Methods are not package-level objects but we still track them in the // object map so that we can handle them like regular functions (if the // receiver is invalid); also we need their fdecl info when associating // them with their receiver base type, below. check.objMap[obj] = info obj.setOrder(uint32(len(check.objMap))) default: check.errorf(s, InvalidSyntaxTree, "unknown syntax.Decl node %T", s) } } } // verify that objects in package and file scopes have different names for _, scope := range fileScopes { for name, obj := range scope.elems { if alt := pkg.scope.Lookup(name); alt != nil { obj = resolve(name, obj) var err error_ err.code = DuplicateDecl if pkg, ok := obj.(*PkgName); ok { err.errorf(alt, "%s already declared through import of %s", alt.Name(), pkg.Imported()) err.recordAltDecl(pkg) } else { err.errorf(alt, "%s already declared through dot-import of %s", alt.Name(), obj.Pkg()) // TODO(gri) dot-imported objects don't have a position; recordAltDecl won't print anything err.recordAltDecl(obj) } check.report(&err) } } } // Now that we have all package scope objects and all methods, // associate methods with receiver base type name where possible. // Ignore methods that have an invalid receiver. They will be // type-checked later, with regular functions. if methods != nil { check.methods = make(map[*TypeName][]*Func) for i := range methods { m := &methods[i] // Determine the receiver base type and associate m with it. ptr, base := check.resolveBaseTypeName(m.ptr, m.recv, fileScopes) if base != nil { m.obj.hasPtrRecv_ = ptr check.methods[base] = append(check.methods[base], m.obj) } } } } // unpackRecv unpacks a receiver type and returns its components: ptr indicates whether // rtyp is a pointer receiver, rname is the receiver type name, and tparams are its // type parameters, if any. The type parameters are only unpacked if unpackParams is // set. If rname is nil, the receiver is unusable (i.e., the source has a bug which we // cannot easily work around). func (check *Checker) unpackRecv(rtyp syntax.Expr, unpackParams bool) (ptr bool, rname *syntax.Name, tparams []*syntax.Name) { L: // unpack receiver type // This accepts invalid receivers such as ***T and does not // work for other invalid receivers, but we don't care. The // validity of receiver expressions is checked elsewhere. for { switch t := rtyp.(type) { case *syntax.ParenExpr: rtyp = t.X // case *ast.StarExpr: // ptr = true // rtyp = t.X case *syntax.Operation: if t.Op != syntax.Mul || t.Y != nil { break } ptr = true rtyp = t.X default: break L } } // unpack type parameters, if any if ptyp, _ := rtyp.(*syntax.IndexExpr); ptyp != nil { rtyp = ptyp.X if unpackParams { for _, arg := range syntax.UnpackListExpr(ptyp.Index) { var par *syntax.Name switch arg := arg.(type) { case *syntax.Name: par = arg case *syntax.BadExpr: // ignore - error already reported by parser case nil: check.error(ptyp, InvalidSyntaxTree, "parameterized receiver contains nil parameters") default: check.errorf(arg, BadDecl, "receiver type parameter %s must be an identifier", arg) } if par == nil { par = syntax.NewName(arg.Pos(), "_") } tparams = append(tparams, par) } } } // unpack receiver name if name, _ := rtyp.(*syntax.Name); name != nil { rname = name } return } // resolveBaseTypeName returns the non-alias base type name for typ, and whether // there was a pointer indirection to get to it. The base type name must be declared // in package scope, and there can be at most one pointer indirection. If no such type // name exists, the returned base is nil. func (check *Checker) resolveBaseTypeName(seenPtr bool, typ syntax.Expr, fileScopes []*Scope) (ptr bool, base *TypeName) { // Algorithm: Starting from a type expression, which may be a name, // we follow that type through alias declarations until we reach a // non-alias type name. If we encounter anything but pointer types or // parentheses we're done. If we encounter more than one pointer type // we're done. ptr = seenPtr var seen map[*TypeName]bool for { // check if we have a pointer type // if pexpr, _ := typ.(*ast.StarExpr); pexpr != nil { if pexpr, _ := typ.(*syntax.Operation); pexpr != nil && pexpr.Op == syntax.Mul && pexpr.Y == nil { // if we've already seen a pointer, we're done if ptr { return false, nil } ptr = true typ = syntax.Unparen(pexpr.X) // continue with pointer base type } // typ must be a name, or a C.name cgo selector. var name string switch typ := typ.(type) { case *syntax.Name: name = typ.Value case *syntax.SelectorExpr: // C.struct_foo is a valid type name for packages using cgo. // // Detect this case, and adjust name so that the correct TypeName is // resolved below. if ident, _ := typ.X.(*syntax.Name); ident != nil && ident.Value == "C" { // Check whether "C" actually resolves to an import of "C", by looking // in the appropriate file scope. var obj Object for _, scope := range fileScopes { if scope.Contains(ident.Pos()) { obj = scope.Lookup(ident.Value) } } // If Config.go115UsesCgo is set, the typechecker will resolve Cgo // selectors to their cgo name. We must do the same here. if pname, _ := obj.(*PkgName); pname != nil { if pname.imported.cgo { // only set if Config.go115UsesCgo is set name = "_Ctype_" + typ.Sel.Value } } } if name == "" { return false, nil } default: return false, nil } // name must denote an object found in the current package scope // (note that dot-imported objects are not in the package scope!) obj := check.pkg.scope.Lookup(name) if obj == nil { return false, nil } // the object must be a type name... tname, _ := obj.(*TypeName) if tname == nil { return false, nil } // ... which we have not seen before if seen[tname] { return false, nil } // we're done if tdecl defined tname as a new type // (rather than an alias) tdecl := check.objMap[tname].tdecl // must exist for objects in package scope if !tdecl.Alias { return ptr, tname } // otherwise, continue resolving typ = tdecl.Type if seen == nil { seen = make(map[*TypeName]bool) } seen[tname] = true } } // packageObjects typechecks all package objects, but not function bodies. func (check *Checker) packageObjects() { // process package objects in source order for reproducible results objList := make([]Object, len(check.objMap)) i := 0 for obj := range check.objMap { objList[i] = obj i++ } sort.Sort(inSourceOrder(objList)) // add new methods to already type-checked types (from a prior Checker.Files call) for _, obj := range objList { if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil { check.collectMethods(obj) } } if check.enableAlias { // With Alias nodes we can process declarations in any order. for _, obj := range objList { check.objDecl(obj, nil) } } else { // Without Alias nodes, we process non-alias type declarations first, followed by // alias declarations, and then everything else. This appears to avoid most situations // where the type of an alias is needed before it is available. // There may still be cases where this is not good enough (see also go.dev/issue/25838). // In those cases Checker.ident will report an error ("invalid use of type alias"). var aliasList []*TypeName var othersList []Object // everything that's not a type // phase 1: non-alias type declarations for _, obj := range objList { if tname, _ := obj.(*TypeName); tname != nil { if check.objMap[tname].tdecl.Alias { aliasList = append(aliasList, tname) } else { check.objDecl(obj, nil) } } else { othersList = append(othersList, obj) } } // phase 2: alias type declarations for _, obj := range aliasList { check.objDecl(obj, nil) } // phase 3: all other declarations for _, obj := range othersList { check.objDecl(obj, nil) } } // At this point we may have a non-empty check.methods map; this means that not all // entries were deleted at the end of typeDecl because the respective receiver base // types were not found. In that case, an error was reported when declaring those // methods. We can now safely discard this map. check.methods = nil } // inSourceOrder implements the sort.Sort interface. type inSourceOrder []Object func (a inSourceOrder) Len() int { return len(a) } func (a inSourceOrder) Less(i, j int) bool { return a[i].order() < a[j].order() } func (a inSourceOrder) Swap(i, j int) { a[i], a[j] = a[j], a[i] } // unusedImports checks for unused imports. func (check *Checker) unusedImports() { // If function bodies are not checked, packages' uses are likely missing - don't check. if check.conf.IgnoreFuncBodies { return } // spec: "It is illegal (...) to directly import a package without referring to // any of its exported identifiers. To import a package solely for its side-effects // (initialization), use the blank identifier as explicit package name." for _, obj := range check.imports { if !obj.used && obj.name != "_" { check.errorUnusedPkg(obj) } } } func (check *Checker) errorUnusedPkg(obj *PkgName) { // If the package was imported with a name other than the final // import path element, show it explicitly in the error message. // Note that this handles both renamed imports and imports of // packages containing unconventional package declarations. // Note that this uses / always, even on Windows, because Go import // paths always use forward slashes. path := obj.imported.path elem := path if i := strings.LastIndex(elem, "/"); i >= 0 { elem = elem[i+1:] } if obj.name == "" || obj.name == "." || obj.name == elem { check.softErrorf(obj, UnusedImport, "%q imported and not used", path) } else { check.softErrorf(obj, UnusedImport, "%q imported as %s and not used", path, obj.name) } } // dir makes a good-faith attempt to return the directory // portion of path. If path is empty, the result is ".". // (Per the go/build package dependency tests, we cannot import // path/filepath and simply use filepath.Dir.) func dir(path string) string { if i := strings.LastIndexAny(path, `/\`); i > 0 { return path[:i] } // i <= 0 return "." } PK ! {�ս^ ^ typelists.gonu �[��� // Copyright 2021 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 types2 // TypeParamList holds a list of type parameters. type TypeParamList struct{ tparams []*TypeParam } // Len returns the number of type parameters in the list. // It is safe to call on a nil receiver. func (l *TypeParamList) Len() int { return len(l.list()) } // At returns the i'th type parameter in the list. func (l *TypeParamList) At(i int) *TypeParam { return l.tparams[i] } // list is for internal use where we expect a []*TypeParam. // TODO(rfindley): list should probably be eliminated: we can pass around a // TypeParamList instead. func (l *TypeParamList) list() []*TypeParam { if l == nil { return nil } return l.tparams } // TypeList holds a list of types. type TypeList struct{ types []Type } // newTypeList returns a new TypeList with the types in list. func newTypeList(list []Type) *TypeList { if len(list) == 0 { return nil } return &TypeList{list} } // Len returns the number of types in the list. // It is safe to call on a nil receiver. func (l *TypeList) Len() int { return len(l.list()) } // At returns the i'th type in the list. func (l *TypeList) At(i int) Type { return l.types[i] } // list is for internal use where we expect a []Type. // TODO(rfindley): list should probably be eliminated: we can pass around a // TypeList instead. func (l *TypeList) list() []Type { if l == nil { return nil } return l.types } // ---------------------------------------------------------------------------- // Implementation func bindTParams(list []*TypeParam) *TypeParamList { if len(list) == 0 { return nil } for i, typ := range list { if typ.index >= 0 { panic("type parameter bound more than once") } typ.index = i } return &TypeParamList{tparams: list} } PK ! �*��c+ c+ builtins_test.gonu �[��� // Copyright 2013 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 types2_test import ( "cmd/compile/internal/syntax" "fmt" "testing" . "cmd/compile/internal/types2" ) var builtinCalls = []struct { name, src, sig string }{ {"append", `var s []int; _ = append(s)`, `func([]int, ...int) []int`}, {"append", `var s []int; _ = append(s, 0)`, `func([]int, ...int) []int`}, {"append", `var s []int; _ = (append)(s, 0)`, `func([]int, ...int) []int`}, {"append", `var s []byte; _ = ((append))(s, 0)`, `func([]byte, ...byte) []byte`}, {"append", `var s []byte; _ = append(s, "foo"...)`, `func([]byte, string...) []byte`}, {"append", `type T []byte; var s T; var str string; _ = append(s, str...)`, `func(p.T, string...) p.T`}, {"append", `type T []byte; type U string; var s T; var str U; _ = append(s, str...)`, `func(p.T, p.U...) p.T`}, {"cap", `var s [10]int; _ = cap(s)`, `invalid type`}, // constant {"cap", `var s [10]int; _ = cap(&s)`, `invalid type`}, // constant {"cap", `var s []int64; _ = cap(s)`, `func([]int64) int`}, {"cap", `var c chan<-bool; _ = cap(c)`, `func(chan<- bool) int`}, {"cap", `type S []byte; var s S; _ = cap(s)`, `func(p.S) int`}, {"cap", `var s P; _ = cap(s)`, `func(P) int`}, {"len", `_ = len("foo")`, `invalid type`}, // constant {"len", `var s string; _ = len(s)`, `func(string) int`}, {"len", `var s [10]int; _ = len(s)`, `invalid type`}, // constant {"len", `var s [10]int; _ = len(&s)`, `invalid type`}, // constant {"len", `var s []int64; _ = len(s)`, `func([]int64) int`}, {"len", `var c chan<-bool; _ = len(c)`, `func(chan<- bool) int`}, {"len", `var m map[string]float32; _ = len(m)`, `func(map[string]float32) int`}, {"len", `type S []byte; var s S; _ = len(s)`, `func(p.S) int`}, {"len", `var s P; _ = len(s)`, `func(P) int`}, {"clear", `var m map[float64]int; clear(m)`, `func(map[float64]int)`}, {"clear", `var s []byte; clear(s)`, `func([]byte)`}, {"close", `var c chan int; close(c)`, `func(chan int)`}, {"close", `var c chan<- chan string; close(c)`, `func(chan<- chan string)`}, {"complex", `_ = complex(1, 0)`, `invalid type`}, // constant {"complex", `var re float32; _ = complex(re, 1.0)`, `func(float32, float32) complex64`}, {"complex", `var im float64; _ = complex(1, im)`, `func(float64, float64) complex128`}, {"complex", `type F32 float32; var re, im F32; _ = complex(re, im)`, `func(p.F32, p.F32) complex64`}, {"complex", `type F64 float64; var re, im F64; _ = complex(re, im)`, `func(p.F64, p.F64) complex128`}, {"copy", `var src, dst []byte; copy(dst, src)`, `func([]byte, []byte) int`}, {"copy", `type T [][]int; var src, dst T; _ = copy(dst, src)`, `func(p.T, p.T) int`}, {"copy", `var src string; var dst []byte; copy(dst, src)`, `func([]byte, string) int`}, {"copy", `type T string; type U []byte; var src T; var dst U; copy(dst, src)`, `func(p.U, p.T) int`}, {"copy", `var dst []byte; copy(dst, "hello")`, `func([]byte, string) int`}, {"delete", `var m map[string]bool; delete(m, "foo")`, `func(map[string]bool, string)`}, {"delete", `type (K string; V int); var m map[K]V; delete(m, "foo")`, `func(map[p.K]p.V, p.K)`}, {"imag", `_ = imag(1i)`, `invalid type`}, // constant {"imag", `var c complex64; _ = imag(c)`, `func(complex64) float32`}, {"imag", `var c complex128; _ = imag(c)`, `func(complex128) float64`}, {"imag", `type C64 complex64; var c C64; _ = imag(c)`, `func(p.C64) float32`}, {"imag", `type C128 complex128; var c C128; _ = imag(c)`, `func(p.C128) float64`}, {"real", `_ = real(1i)`, `invalid type`}, // constant {"real", `var c complex64; _ = real(c)`, `func(complex64) float32`}, {"real", `var c complex128; _ = real(c)`, `func(complex128) float64`}, {"real", `type C64 complex64; var c C64; _ = real(c)`, `func(p.C64) float32`}, {"real", `type C128 complex128; var c C128; _ = real(c)`, `func(p.C128) float64`}, {"make", `_ = make([]int, 10)`, `func([]int, int) []int`}, {"make", `type T []byte; _ = make(T, 10, 20)`, `func(p.T, int, int) p.T`}, // go.dev/issue/37349 {"make", ` _ = make([]int, 0 )`, `func([]int, int) []int`}, {"make", `var l int; _ = make([]int, l )`, `func([]int, int) []int`}, {"make", ` _ = make([]int, 0, 0)`, `func([]int, int, int) []int`}, {"make", `var l int; _ = make([]int, l, 0)`, `func([]int, int, int) []int`}, {"make", `var c int; _ = make([]int, 0, c)`, `func([]int, int, int) []int`}, {"make", `var l, c int; _ = make([]int, l, c)`, `func([]int, int, int) []int`}, // go.dev/issue/37393 {"make", ` _ = make([]int , 0 )`, `func([]int, int) []int`}, {"make", `var l byte ; _ = make([]int8 , l )`, `func([]int8, byte) []int8`}, {"make", ` _ = make([]int16 , 0, 0)`, `func([]int16, int, int) []int16`}, {"make", `var l int16; _ = make([]string , l, 0)`, `func([]string, int16, int) []string`}, {"make", `var c int32; _ = make([]float64 , 0, c)`, `func([]float64, int, int32) []float64`}, {"make", `var l, c uint ; _ = make([]complex128, l, c)`, `func([]complex128, uint, uint) []complex128`}, // go.dev/issue/45667 {"make", `const l uint = 1; _ = make([]int, l)`, `func([]int, uint) []int`}, {"max", ` _ = max(0 )`, `invalid type`}, // constant {"max", `var x int ; _ = max(x )`, `func(int) int`}, {"max", `var x int ; _ = max(0, x )`, `func(int, int) int`}, {"max", `var x string ; _ = max("a", x )`, `func(string, string) string`}, {"max", `var x float32; _ = max(0, 1.0, x)`, `func(float32, float32, float32) float32`}, {"min", ` _ = min(0 )`, `invalid type`}, // constant {"min", `var x int ; _ = min(x )`, `func(int) int`}, {"min", `var x int ; _ = min(0, x )`, `func(int, int) int`}, {"min", `var x string ; _ = min("a", x )`, `func(string, string) string`}, {"min", `var x float32; _ = min(0, 1.0, x)`, `func(float32, float32, float32) float32`}, {"new", `_ = new(int)`, `func(int) *int`}, {"new", `type T struct{}; _ = new(T)`, `func(p.T) *p.T`}, {"panic", `panic(0)`, `func(interface{})`}, {"panic", `panic("foo")`, `func(interface{})`}, {"print", `print()`, `func()`}, {"print", `print(0)`, `func(int)`}, {"print", `print(1, 2.0, "foo", true)`, `func(int, float64, string, bool)`}, {"println", `println()`, `func()`}, {"println", `println(0)`, `func(int)`}, {"println", `println(1, 2.0, "foo", true)`, `func(int, float64, string, bool)`}, {"recover", `recover()`, `func() interface{}`}, {"recover", `_ = recover()`, `func() interface{}`}, {"Add", `var p unsafe.Pointer; _ = unsafe.Add(p, -1.0)`, `func(unsafe.Pointer, int) unsafe.Pointer`}, {"Add", `var p unsafe.Pointer; var n uintptr; _ = unsafe.Add(p, n)`, `func(unsafe.Pointer, uintptr) unsafe.Pointer`}, {"Add", `_ = unsafe.Add(nil, 0)`, `func(unsafe.Pointer, int) unsafe.Pointer`}, {"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`}, // constant {"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant {"Alignof", `var x P; _ = unsafe.Alignof(x)`, `func(P) uintptr`}, {"Offsetof", `var x struct{f bool}; _ = unsafe.Offsetof(x.f)`, `invalid type`}, // constant {"Offsetof", `var x struct{_ int; f bool}; _ = unsafe.Offsetof((&x).f)`, `invalid type`}, // constant {"Offsetof", `var x struct{_ int; f P}; _ = unsafe.Offsetof((&x).f)`, `func(P) uintptr`}, {"Sizeof", `_ = unsafe.Sizeof(0)`, `invalid type`}, // constant {"Sizeof", `var x struct{}; _ = unsafe.Sizeof(x)`, `invalid type`}, // constant {"Sizeof", `var x P; _ = unsafe.Sizeof(x)`, `func(P) uintptr`}, {"Slice", `var p *int; _ = unsafe.Slice(p, 1)`, `func(*int, int) []int`}, {"Slice", `var p *byte; var n uintptr; _ = unsafe.Slice(p, n)`, `func(*byte, uintptr) []byte`}, {"Slice", `type B *byte; var b B; _ = unsafe.Slice(b, 0)`, `func(*byte, int) []byte`}, {"SliceData", "var s []int; _ = unsafe.SliceData(s)", `func([]int) *int`}, {"SliceData", "type S []int; var s S; _ = unsafe.SliceData(s)", `func([]int) *int`}, {"String", `var p *byte; _ = unsafe.String(p, 1)`, `func(*byte, int) string`}, {"String", `type B *byte; var b B; _ = unsafe.String(b, 0)`, `func(*byte, int) string`}, {"StringData", `var s string; _ = unsafe.StringData(s)`, `func(string) *byte`}, {"StringData", `_ = unsafe.StringData("foo")`, `func(string) *byte`}, {"assert", `assert(true)`, `invalid type`}, // constant {"assert", `type B bool; const pred B = 1 < 2; assert(pred)`, `invalid type`}, // constant // no tests for trace since it produces output as a side-effect } func TestBuiltinSignatures(t *testing.T) { DefPredeclaredTestFuncs() seen := map[string]bool{"trace": true} // no test for trace built-in; add it manually for _, call := range builtinCalls { testBuiltinSignature(t, call.name, call.src, call.sig) seen[call.name] = true } // make sure we didn't miss one for _, name := range Universe.Names() { if _, ok := Universe.Lookup(name).(*Builtin); ok && !seen[name] { t.Errorf("missing test for %s", name) } } for _, name := range Unsafe.Scope().Names() { if _, ok := Unsafe.Scope().Lookup(name).(*Builtin); ok && !seen[name] { t.Errorf("missing test for unsafe.%s", name) } } } func testBuiltinSignature(t *testing.T, name, src0, want string) { src := fmt.Sprintf(`package p; import "unsafe"; type _ unsafe.Pointer /* use unsafe */; func _[P ~[]byte]() { %s }`, src0) uses := make(map[*syntax.Name]Object) types := make(map[syntax.Expr]TypeAndValue) mustTypecheck(src, nil, &Info{Uses: uses, Types: types}) // find called function n := 0 var fun syntax.Expr for x := range types { if call, _ := x.(*syntax.CallExpr); call != nil { fun = call.Fun n++ } } if n != 1 { t.Errorf("%s: got %d CallExprs; want 1", src0, n) return } // check recorded types for fun and descendents (may be parenthesized) for { // the recorded type for the built-in must match the wanted signature typ := types[fun].Type if typ == nil { t.Errorf("%s: no type recorded for %s", src0, syntax.String(fun)) return } if got := typ.String(); got != want { t.Errorf("%s: got type %s; want %s", src0, got, want) return } // called function must be a (possibly parenthesized, qualified) // identifier denoting the expected built-in switch p := fun.(type) { case *syntax.Name: obj := uses[p] if obj == nil { t.Errorf("%s: no object found for %s", src0, p.Value) return } bin, _ := obj.(*Builtin) if bin == nil { t.Errorf("%s: %s does not denote a built-in", src0, p.Value) return } if bin.Name() != name { t.Errorf("%s: got built-in %s; want %s", src0, bin.Name(), name) return } return // we're done case *syntax.ParenExpr: fun = p.X // unpack case *syntax.SelectorExpr: // built-in from package unsafe - ignore details return // we're done default: t.Errorf("%s: invalid function call", src0) return } } } PK ! 4G�H4 4 context.gonu �[��� // Copyright 2021 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 types2 import ( "bytes" "fmt" "strconv" "strings" "sync" ) // This file contains a definition of the type-checking context; an opaque type // that may be supplied by users during instantiation. // // Contexts serve two purposes: // - reduce the duplication of identical instances // - short-circuit instantiation cycles // // For the latter purpose, we must always have a context during instantiation, // whether or not it is supplied by the user. For both purposes, it must be the // case that hashing a pointer-identical type produces consistent results // (somewhat obviously). // // However, neither of these purposes require that our hash is perfect, and so // this was not an explicit design goal of the context type. In fact, due to // concurrent use it is convenient not to guarantee de-duplication. // // Nevertheless, in the future it could be helpful to allow users to leverage // contexts to canonicalize instances, and it would probably be possible to // achieve such a guarantee. // A Context is an opaque type checking context. It may be used to share // identical type instances across type-checked packages or calls to // Instantiate. Contexts are safe for concurrent use. // // The use of a shared context does not guarantee that identical instances are // deduplicated in all cases. type Context struct { mu sync.Mutex typeMap map[string][]ctxtEntry // type hash -> instances entries nextID int // next unique ID originIDs map[Type]int // origin type -> unique ID } type ctxtEntry struct { orig Type targs []Type instance Type // = orig[targs] } // NewContext creates a new Context. func NewContext() *Context { return &Context{ typeMap: make(map[string][]ctxtEntry), originIDs: make(map[Type]int), } } // instanceHash returns a string representation of typ instantiated with targs. // The hash should be a perfect hash, though out of caution the type checker // does not assume this. The result is guaranteed to not contain blanks. func (ctxt *Context) instanceHash(orig Type, targs []Type) string { assert(ctxt != nil) assert(orig != nil) var buf bytes.Buffer h := newTypeHasher(&buf, ctxt) h.string(strconv.Itoa(ctxt.getID(orig))) // Because we've already written the unique origin ID this call to h.typ is // unnecessary, but we leave it for hash readability. It can be removed later // if performance is an issue. h.typ(orig) if len(targs) > 0 { // TODO(rfindley): consider asserting on isGeneric(typ) here, if and when // isGeneric handles *Signature types. h.typeList(targs) } return strings.ReplaceAll(buf.String(), " ", "#") } // lookup returns an existing instantiation of orig with targs, if it exists. // Otherwise, it returns nil. func (ctxt *Context) lookup(h string, orig Type, targs []Type) Type { ctxt.mu.Lock() defer ctxt.mu.Unlock() for _, e := range ctxt.typeMap[h] { if identicalInstance(orig, targs, e.orig, e.targs) { return e.instance } if debug { // Panic during development to surface any imperfections in our hash. panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e.instance)) } } return nil } // update de-duplicates n against previously seen types with the hash h. If an // identical type is found with the type hash h, the previously seen type is // returned. Otherwise, n is returned, and recorded in the Context for the hash // h. func (ctxt *Context) update(h string, orig Type, targs []Type, inst Type) Type { assert(inst != nil) ctxt.mu.Lock() defer ctxt.mu.Unlock() for _, e := range ctxt.typeMap[h] { if inst == nil || Identical(inst, e.instance) { return e.instance } if debug { // Panic during development to surface any imperfections in our hash. panic(fmt.Sprintf("%s and %s are not identical", inst, e.instance)) } } ctxt.typeMap[h] = append(ctxt.typeMap[h], ctxtEntry{ orig: orig, targs: targs, instance: inst, }) return inst } // getID returns a unique ID for the type t. func (ctxt *Context) getID(t Type) int { ctxt.mu.Lock() defer ctxt.mu.Unlock() id, ok := ctxt.originIDs[t] if !ok { id = ctxt.nextID ctxt.originIDs[t] = id ctxt.nextID++ } return id } PK ! ��8��K �K object.gonu �[��� // Copyright 2013 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 types2 import ( "bytes" "cmd/compile/internal/syntax" "fmt" "go/constant" "unicode" "unicode/utf8" ) // An Object describes a named language entity such as a package, // constant, type, variable, function (incl. methods), or label. // All objects implement the Object interface. type Object interface { Parent() *Scope // scope in which this object is declared; nil for methods and struct fields Pos() syntax.Pos // position of object identifier in declaration Pkg() *Package // package to which this object belongs; nil for labels and objects in the Universe scope Name() string // package local object name Type() Type // object type Exported() bool // reports whether the name starts with a capital letter Id() string // object name if exported, qualified name if not exported (see func Id) // String returns a human-readable string of the object. String() string // order reflects a package-level object's source order: if object // a is before object b in the source, then a.order() < b.order(). // order returns a value > 0 for package-level objects; it returns // 0 for all other objects (including objects in file scopes). order() uint32 // color returns the object's color. color() color // setType sets the type of the object. setType(Type) // setOrder sets the order number of the object. It must be > 0. setOrder(uint32) // setColor sets the object's color. It must not be white. setColor(color color) // setParent sets the parent scope of the object. setParent(*Scope) // sameId reports whether obj.Id() and Id(pkg, name) are the same. sameId(pkg *Package, name string) bool // scopePos returns the start position of the scope of this Object scopePos() syntax.Pos // setScopePos sets the start position of the scope for this Object. setScopePos(pos syntax.Pos) } func isExported(name string) bool { ch, _ := utf8.DecodeRuneInString(name) return unicode.IsUpper(ch) } // Id returns name if it is exported, otherwise it // returns the name qualified with the package path. func Id(pkg *Package, name string) string { if isExported(name) { return name } // unexported names need the package path for differentiation // (if there's no package, make sure we don't start with '.' // as that may change the order of methods between a setup // inside a package and outside a package - which breaks some // tests) path := "_" // pkg is nil for objects in Universe scope and possibly types // introduced via Eval (see also comment in object.sameId) if pkg != nil && pkg.path != "" { path = pkg.path } return path + "." + name } // An object implements the common parts of an Object. type object struct { parent *Scope pos syntax.Pos pkg *Package name string typ Type order_ uint32 color_ color scopePos_ syntax.Pos } // color encodes the color of an object (see Checker.objDecl for details). type color uint32 // An object may be painted in one of three colors. // Color values other than white or black are considered grey. const ( white color = iota black grey // must be > white and black ) func (c color) String() string { switch c { case white: return "white" case black: return "black" default: return "grey" } } // colorFor returns the (initial) color for an object depending on // whether its type t is known or not. func colorFor(t Type) color { if t != nil { return black } return white } // Parent returns the scope in which the object is declared. // The result is nil for methods and struct fields. func (obj *object) Parent() *Scope { return obj.parent } // Pos returns the declaration position of the object's identifier. func (obj *object) Pos() syntax.Pos { return obj.pos } // Pkg returns the package to which the object belongs. // The result is nil for labels and objects in the Universe scope. func (obj *object) Pkg() *Package { return obj.pkg } // Name returns the object's (package-local, unqualified) name. func (obj *object) Name() string { return obj.name } // Type returns the object's type. func (obj *object) Type() Type { return obj.typ } // Exported reports whether the object is exported (starts with a capital letter). // It doesn't take into account whether the object is in a local (function) scope // or not. func (obj *object) Exported() bool { return isExported(obj.name) } // Id is a wrapper for Id(obj.Pkg(), obj.Name()). func (obj *object) Id() string { return Id(obj.pkg, obj.name) } func (obj *object) String() string { panic("abstract") } func (obj *object) order() uint32 { return obj.order_ } func (obj *object) color() color { return obj.color_ } func (obj *object) scopePos() syntax.Pos { return obj.scopePos_ } func (obj *object) setParent(parent *Scope) { obj.parent = parent } func (obj *object) setType(typ Type) { obj.typ = typ } func (obj *object) setOrder(order uint32) { assert(order > 0); obj.order_ = order } func (obj *object) setColor(color color) { assert(color != white); obj.color_ = color } func (obj *object) setScopePos(pos syntax.Pos) { obj.scopePos_ = pos } func (obj *object) sameId(pkg *Package, name string) bool { // spec: // "Two identifiers are different if they are spelled differently, // or if they appear in different packages and are not exported. // Otherwise, they are the same." if name != obj.name { return false } // obj.Name == name if obj.Exported() { return true } // not exported, so packages must be the same (pkg == nil for // fields in Universe scope; this can only happen for types // introduced via Eval) if pkg == nil || obj.pkg == nil { return pkg == obj.pkg } // pkg != nil && obj.pkg != nil return pkg.path == obj.pkg.path } // less reports whether object a is ordered before object b. // // Objects are ordered nil before non-nil, exported before // non-exported, then by name, and finally (for non-exported // functions) by package path. func (a *object) less(b *object) bool { if a == b { return false } // Nil before non-nil. if a == nil { return true } if b == nil { return false } // Exported functions before non-exported. ea := isExported(a.name) eb := isExported(b.name) if ea != eb { return ea } // Order by name and then (for non-exported names) by package. if a.name != b.name { return a.name < b.name } if !ea { return a.pkg.path < b.pkg.path } return false } // A PkgName represents an imported Go package. // PkgNames don't have a type. type PkgName struct { object imported *Package used bool // set if the package was used } // NewPkgName returns a new PkgName object representing an imported package. // The remaining arguments set the attributes found with all Objects. func NewPkgName(pos syntax.Pos, pkg *Package, name string, imported *Package) *PkgName { return &PkgName{object{nil, pos, pkg, name, Typ[Invalid], 0, black, nopos}, imported, false} } // Imported returns the package that was imported. // It is distinct from Pkg(), which is the package containing the import statement. func (obj *PkgName) Imported() *Package { return obj.imported } // A Const represents a declared constant. type Const struct { object val constant.Value } // NewConst returns a new constant with value val. // The remaining arguments set the attributes found with all Objects. func NewConst(pos syntax.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const { return &Const{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, val} } // Val returns the constant's value. func (obj *Const) Val() constant.Value { return obj.val } func (*Const) isDependency() {} // a constant may be a dependency of an initialization expression // A TypeName represents a name for a (defined or alias) type. type TypeName struct { object } // NewTypeName returns a new type name denoting the given typ. // The remaining arguments set the attributes found with all Objects. // // The typ argument may be a defined (Named) type or an alias type. // It may also be nil such that the returned TypeName can be used as // argument for NewNamed, which will set the TypeName's type as a side- // effect. func NewTypeName(pos syntax.Pos, pkg *Package, name string, typ Type) *TypeName { return &TypeName{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}} } // NewTypeNameLazy returns a new defined type like NewTypeName, but it // lazily calls resolve to finish constructing the Named object. func NewTypeNameLazy(pos syntax.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName { obj := NewTypeName(pos, pkg, name, nil) NewNamed(obj, nil, nil).loader = load return obj } // IsAlias reports whether obj is an alias name for a type. func (obj *TypeName) IsAlias() bool { switch t := obj.typ.(type) { case nil: return false // case *Alias: // handled by default case case *Basic: // unsafe.Pointer is not an alias. if obj.pkg == Unsafe { return false } // Any user-defined type name for a basic type is an alias for a // basic type (because basic types are pre-declared in the Universe // scope, outside any package scope), and so is any type name with // a different name than the name of the basic type it refers to. // Additionally, we need to look for "byte" and "rune" because they // are aliases but have the same names (for better error messages). return obj.pkg != nil || t.name != obj.name || t == universeByte || t == universeRune case *Named: return obj != t.obj case *TypeParam: return obj != t.obj default: return true } } // A Variable represents a declared variable (including function parameters and results, and struct fields). type Var struct { object embedded bool // if set, the variable is an embedded struct field, and name is the type name isField bool // var is struct field used bool // set if the variable was used origin *Var // if non-nil, the Var from which this one was instantiated } // NewVar returns a new variable. // The arguments set the attributes found with all Objects. func NewVar(pos syntax.Pos, pkg *Package, name string, typ Type) *Var { return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}} } // NewParam returns a new variable representing a function parameter. func NewParam(pos syntax.Pos, pkg *Package, name string, typ Type) *Var { return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, used: true} // parameters are always 'used' } // NewField returns a new variable representing a struct field. // For embedded fields, the name is the unqualified type name // under which the field is accessible. func NewField(pos syntax.Pos, pkg *Package, name string, typ Type, embedded bool) *Var { return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, embedded: embedded, isField: true} } // Anonymous reports whether the variable is an embedded field. // Same as Embedded; only present for backward-compatibility. func (obj *Var) Anonymous() bool { return obj.embedded } // Embedded reports whether the variable is an embedded field. func (obj *Var) Embedded() bool { return obj.embedded } // IsField reports whether the variable is a struct field. func (obj *Var) IsField() bool { return obj.isField } // Origin returns the canonical Var for its receiver, i.e. the Var object // recorded in Info.Defs. // // For synthetic Vars created during instantiation (such as struct fields or // function parameters that depend on type arguments), this will be the // corresponding Var on the generic (uninstantiated) type. For all other Vars // Origin returns the receiver. func (obj *Var) Origin() *Var { if obj.origin != nil { return obj.origin } return obj } func (*Var) isDependency() {} // a variable may be a dependency of an initialization expression // A Func represents a declared function, concrete method, or abstract // (interface) method. Its Type() is always a *Signature. // An abstract method may belong to many interfaces due to embedding. type Func struct { object hasPtrRecv_ bool // only valid for methods that don't have a type yet; use hasPtrRecv() to read origin *Func // if non-nil, the Func from which this one was instantiated } // NewFunc returns a new function with the given signature, representing // the function's type. func NewFunc(pos syntax.Pos, pkg *Package, name string, sig *Signature) *Func { // don't store a (typed) nil signature var typ Type if sig != nil { typ = sig } return &Func{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, false, nil} } // FullName returns the package- or receiver-type-qualified name of // function or method obj. func (obj *Func) FullName() string { var buf bytes.Buffer writeFuncName(&buf, obj, nil) return buf.String() } // Scope returns the scope of the function's body block. // The result is nil for imported or instantiated functions and methods // (but there is also no mechanism to get to an instantiated function). func (obj *Func) Scope() *Scope { return obj.typ.(*Signature).scope } // Origin returns the canonical Func for its receiver, i.e. the Func object // recorded in Info.Defs. // // For synthetic functions created during instantiation (such as methods on an // instantiated Named type or interface methods that depend on type arguments), // this will be the corresponding Func on the generic (uninstantiated) type. // For all other Funcs Origin returns the receiver. func (obj *Func) Origin() *Func { if obj.origin != nil { return obj.origin } return obj } // Pkg returns the package to which the function belongs. // // The result is nil for methods of types in the Universe scope, // like method Error of the error built-in interface type. func (obj *Func) Pkg() *Package { return obj.object.Pkg() } // hasPtrRecv reports whether the receiver is of the form *T for the given method obj. func (obj *Func) hasPtrRecv() bool { // If a method's receiver type is set, use that as the source of truth for the receiver. // Caution: Checker.funcDecl (decl.go) marks a function by setting its type to an empty // signature. We may reach here before the signature is fully set up: we must explicitly // check if the receiver is set (we cannot just look for non-nil obj.typ). if sig, _ := obj.typ.(*Signature); sig != nil && sig.recv != nil { _, isPtr := deref(sig.recv.typ) return isPtr } // If a method's type is not set it may be a method/function that is: // 1) client-supplied (via NewFunc with no signature), or // 2) internally created but not yet type-checked. // For case 1) we can't do anything; the client must know what they are doing. // For case 2) we can use the information gathered by the resolver. return obj.hasPtrRecv_ } func (*Func) isDependency() {} // a function may be a dependency of an initialization expression // A Label represents a declared label. // Labels don't have a type. type Label struct { object used bool // set if the label was used } // NewLabel returns a new label. func NewLabel(pos syntax.Pos, pkg *Package, name string) *Label { return &Label{object{pos: pos, pkg: pkg, name: name, typ: Typ[Invalid], color_: black}, false} } // A Builtin represents a built-in function. // Builtins don't have a valid type. type Builtin struct { object id builtinId } func newBuiltin(id builtinId) *Builtin { return &Builtin{object{name: predeclaredFuncs[id].name, typ: Typ[Invalid], color_: black}, id} } // Nil represents the predeclared value nil. type Nil struct { object } func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) { var tname *TypeName typ := obj.Type() switch obj := obj.(type) { case *PkgName: fmt.Fprintf(buf, "package %s", obj.Name()) if path := obj.imported.path; path != "" && path != obj.name { fmt.Fprintf(buf, " (%q)", path) } return case *Const: buf.WriteString("const") case *TypeName: tname = obj buf.WriteString("type") if isTypeParam(typ) { buf.WriteString(" parameter") } case *Var: if obj.isField { buf.WriteString("field") } else { buf.WriteString("var") } case *Func: buf.WriteString("func ") writeFuncName(buf, obj, qf) if typ != nil { WriteSignature(buf, typ.(*Signature), qf) } return case *Label: buf.WriteString("label") typ = nil case *Builtin: buf.WriteString("builtin") typ = nil case *Nil: buf.WriteString("nil") return default: panic(fmt.Sprintf("writeObject(%T)", obj)) } buf.WriteByte(' ') // For package-level objects, qualify the name. if obj.Pkg() != nil && obj.Pkg().scope.Lookup(obj.Name()) == obj { buf.WriteString(packagePrefix(obj.Pkg(), qf)) } buf.WriteString(obj.Name()) if typ == nil { return } if tname != nil { switch t := typ.(type) { case *Basic: // Don't print anything more for basic types since there's // no more information. return case *Named: if t.TypeParams().Len() > 0 { newTypeWriter(buf, qf).tParamList(t.TypeParams().list()) } } if tname.IsAlias() { buf.WriteString(" =") } else if t, _ := typ.(*TypeParam); t != nil { typ = t.bound } else { // TODO(gri) should this be fromRHS for *Named? typ = under(typ) } } // Special handling for any: because WriteType will format 'any' as 'any', // resulting in the object string `type any = any` rather than `type any = // interface{}`. To avoid this, swap in a different empty interface. if obj == universeAny { assert(Identical(typ, &emptyInterface)) typ = &emptyInterface } buf.WriteByte(' ') WriteType(buf, typ, qf) } func packagePrefix(pkg *Package, qf Qualifier) string { if pkg == nil { return "" } var s string if qf != nil { s = qf(pkg) } else { s = pkg.Path() } if s != "" { s += "." } return s } // ObjectString returns the string form of obj. // The Qualifier controls the printing of // package-level objects, and may be nil. func ObjectString(obj Object, qf Qualifier) string { var buf bytes.Buffer writeObject(&buf, obj, qf) return buf.String() } func (obj *PkgName) String() string { return ObjectString(obj, nil) } func (obj *Const) String() string { return ObjectString(obj, nil) } func (obj *TypeName) String() string { return ObjectString(obj, nil) } func (obj *Var) String() string { return ObjectString(obj, nil) } func (obj *Func) String() string { return ObjectString(obj, nil) } func (obj *Label) String() string { return ObjectString(obj, nil) } func (obj *Builtin) String() string { return ObjectString(obj, nil) } func (obj *Nil) String() string { return ObjectString(obj, nil) } func writeFuncName(buf *bytes.Buffer, f *Func, qf Qualifier) { if f.typ != nil { sig := f.typ.(*Signature) if recv := sig.Recv(); recv != nil { buf.WriteByte('(') if _, ok := recv.Type().(*Interface); ok { // gcimporter creates abstract methods of // named interfaces using the interface type // (not the named type) as the receiver. // Don't print it in full. buf.WriteString("interface") } else { WriteType(buf, recv.Type(), qf) } buf.WriteByte(')') buf.WriteByte('.') } else if f.pkg != nil { buf.WriteString(packagePrefix(f.pkg, qf)) } } buf.WriteString(f.name) } PK ! �j� � errors.gonu �[��� // Copyright 2012 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. // This file implements various error reporters. package types2 import ( "bytes" "cmd/compile/internal/syntax" "fmt" . "internal/types/errors" "runtime" "strconv" "strings" ) func assert(p bool) { if !p { msg := "assertion failed" // Include information about the assertion location. Due to panic recovery, // this location is otherwise buried in the middle of the panicking stack. if _, file, line, ok := runtime.Caller(1); ok { msg = fmt.Sprintf("%s:%d: %s", file, line, msg) } panic(msg) } } func unreachable() { panic("unreachable") } // An error_ represents a type-checking error. // To report an error_, call Checker.report. type error_ struct { desc []errorDesc code Code soft bool // TODO(gri) eventually determine this from an error code } // An errorDesc describes part of a type-checking error. type errorDesc struct { pos syntax.Pos format string args []interface{} } func (err *error_) empty() bool { return err.desc == nil } func (err *error_) pos() syntax.Pos { if err.empty() { return nopos } return err.desc[0].pos } func (err *error_) msg(qf Qualifier) string { if err.empty() { return "no error" } var buf strings.Builder for i := range err.desc { p := &err.desc[i] if i > 0 { fmt.Fprint(&buf, "\n\t") if p.pos.IsKnown() { fmt.Fprintf(&buf, "%s: ", p.pos) } } buf.WriteString(sprintf(qf, false, p.format, p.args...)) } return buf.String() } // String is for testing. func (err *error_) String() string { if err.empty() { return "no error" } return fmt.Sprintf("%s: %s", err.pos(), err.msg(nil)) } // errorf adds formatted error information to err. // It may be called multiple times to provide additional information. func (err *error_) errorf(at poser, format string, args ...interface{}) { err.desc = append(err.desc, errorDesc{atPos(at), format, args}) } func sprintf(qf Qualifier, tpSubscripts bool, format string, args ...interface{}) string { for i, arg := range args { switch a := arg.(type) { case nil: arg = "<nil>" case operand: panic("got operand instead of *operand") case *operand: arg = operandString(a, qf) case syntax.Pos: arg = a.String() case syntax.Expr: arg = syntax.String(a) case []syntax.Expr: var buf strings.Builder buf.WriteByte('[') for i, x := range a { if i > 0 { buf.WriteString(", ") } buf.WriteString(syntax.String(x)) } buf.WriteByte(']') arg = buf.String() case Object: arg = ObjectString(a, qf) case Type: var buf bytes.Buffer w := newTypeWriter(&buf, qf) w.tpSubscripts = tpSubscripts w.typ(a) arg = buf.String() case []Type: var buf bytes.Buffer w := newTypeWriter(&buf, qf) w.tpSubscripts = tpSubscripts buf.WriteByte('[') for i, x := range a { if i > 0 { buf.WriteString(", ") } w.typ(x) } buf.WriteByte(']') arg = buf.String() case []*TypeParam: var buf bytes.Buffer w := newTypeWriter(&buf, qf) w.tpSubscripts = tpSubscripts buf.WriteByte('[') for i, x := range a { if i > 0 { buf.WriteString(", ") } w.typ(x) } buf.WriteByte(']') arg = buf.String() } args[i] = arg } return fmt.Sprintf(format, args...) } func (check *Checker) qualifier(pkg *Package) string { // Qualify the package unless it's the package being type-checked. if pkg != check.pkg { if check.pkgPathMap == nil { check.pkgPathMap = make(map[string]map[string]bool) check.seenPkgMap = make(map[*Package]bool) check.markImports(check.pkg) } // If the same package name was used by multiple packages, display the full path. if len(check.pkgPathMap[pkg.name]) > 1 { return strconv.Quote(pkg.path) } return pkg.name } return "" } // markImports recursively walks pkg and its imports, to record unique import // paths in pkgPathMap. func (check *Checker) markImports(pkg *Package) { if check.seenPkgMap[pkg] { return } check.seenPkgMap[pkg] = true forName, ok := check.pkgPathMap[pkg.name] if !ok { forName = make(map[string]bool) check.pkgPathMap[pkg.name] = forName } forName[pkg.path] = true for _, imp := range pkg.imports { check.markImports(imp) } } // check may be nil. func (check *Checker) sprintf(format string, args ...interface{}) string { var qf Qualifier if check != nil { qf = check.qualifier } return sprintf(qf, false, format, args...) } func (check *Checker) report(err *error_) { if err.empty() { panic("no error to report") } check.err(err.pos(), err.code, err.msg(check.qualifier), err.soft) } func (check *Checker) trace(pos syntax.Pos, format string, args ...interface{}) { fmt.Printf("%s:\t%s%s\n", pos, strings.Repeat(". ", check.indent), sprintf(check.qualifier, true, format, args...), ) } // dump is only needed for debugging func (check *Checker) dump(format string, args ...interface{}) { fmt.Println(sprintf(check.qualifier, true, format, args...)) } func (check *Checker) err(at poser, code Code, msg string, soft bool) { switch code { case InvalidSyntaxTree: msg = "invalid syntax tree: " + msg case 0: panic("no error code provided") } // Cheap trick: Don't report errors with messages containing // "invalid operand" or "invalid type" as those tend to be // follow-on errors which don't add useful information. Only // exclude them if these strings are not at the beginning, // and only if we have at least one error already reported. if check.firstErr != nil && (strings.Index(msg, "invalid operand") > 0 || strings.Index(msg, "invalid type") > 0) { return } pos := atPos(at) // If we are encountering an error while evaluating an inherited // constant initialization expression, pos is the position of in // the original expression, and not of the currently declared // constant identifier. Use the provided errpos instead. // TODO(gri) We may also want to augment the error message and // refer to the position (pos) in the original expression. if check.errpos.IsKnown() { assert(check.iota != nil) pos = check.errpos } // If we have a URL for error codes, add a link to the first line. if code != 0 && check.conf.ErrorURL != "" { u := fmt.Sprintf(check.conf.ErrorURL, code) if i := strings.Index(msg, "\n"); i >= 0 { msg = msg[:i] + u + msg[i:] } else { msg += u } } err := Error{pos, stripAnnotations(msg), msg, soft, code} if check.firstErr == nil { check.firstErr = err } if check.conf.Trace { check.trace(pos, "ERROR: %s", msg) } f := check.conf.Error if f == nil { panic(bailout{}) // report only first error } f(err) } const ( invalidArg = "invalid argument: " invalidOp = "invalid operation: " ) type poser interface { Pos() syntax.Pos } func (check *Checker) error(at poser, code Code, msg string) { check.err(at, code, msg, false) } func (check *Checker) errorf(at poser, code Code, format string, args ...interface{}) { check.err(at, code, check.sprintf(format, args...), false) } func (check *Checker) softErrorf(at poser, code Code, format string, args ...interface{}) { check.err(at, code, check.sprintf(format, args...), true) } func (check *Checker) versionErrorf(at poser, v goVersion, format string, args ...interface{}) { msg := check.sprintf(format, args...) msg = fmt.Sprintf("%s requires %s or later", msg, v) check.err(at, UnsupportedFeature, msg, true) } // atPos reports the left (= start) position of at. func atPos(at poser) syntax.Pos { switch x := at.(type) { case *operand: if x.expr != nil { return syntax.StartPos(x.expr) } case syntax.Node: return syntax.StartPos(x) } return at.Pos() } // stripAnnotations removes internal (type) annotations from s. func stripAnnotations(s string) string { var buf strings.Builder for _, r := range s { // strip #'s and subscript digits if r < '₀' || '₀'+10 <= r { // '₀' == U+2080 buf.WriteRune(r) } } if buf.Len() < len(s) { return buf.String() } return s } PK ! � �� � lookup_test.gonu �[��� // Copyright 2022 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 types2_test import ( "path/filepath" "runtime" "testing" . "cmd/compile/internal/types2" ) // BenchmarkLookupFieldOrMethod measures types.LookupFieldOrMethod performance. // LookupFieldOrMethod is a performance hotspot for both type-checking and // external API calls. func BenchmarkLookupFieldOrMethod(b *testing.B) { // Choose an arbitrary, large package. path := filepath.Join(runtime.GOROOT(), "src", "net", "http") files, err := pkgFiles(path) if err != nil { b.Fatal(err) } conf := Config{ Importer: defaultImporter(), } pkg, err := conf.Check("http", files, nil) if err != nil { b.Fatal(err) } scope := pkg.Scope() names := scope.Names() // Look up an arbitrary name for each type referenced in the package scope. lookup := func() { for _, name := range names { typ := scope.Lookup(name).Type() LookupFieldOrMethod(typ, true, pkg, "m") } } // Perform a lookup once, to ensure that any lazily-evaluated state is // complete. lookup() b.ResetTimer() for i := 0; i < b.N; i++ { lookup() } } PK ! �xB�2 �2 signature.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" "fmt" . "internal/types/errors" ) // ---------------------------------------------------------------------------- // API // A Signature represents a (non-builtin) function or method type. // The receiver is ignored when comparing signatures for identity. type Signature struct { // We need to keep the scope in Signature (rather than passing it around // and store it in the Func Object) because when type-checking a function // literal we call the general type checker which returns a general Type. // We then unpack the *Signature and use the scope for the literal body. rparams *TypeParamList // receiver type parameters from left to right, or nil tparams *TypeParamList // type parameters from left to right, or nil scope *Scope // function scope for package-local and non-instantiated signatures; nil otherwise recv *Var // nil if not a method params *Tuple // (incoming) parameters from left to right; or nil results *Tuple // (outgoing) results from left to right; or nil variadic bool // true if the last parameter's type is of the form ...T (or string, for append built-in only) } // NewSignatureType creates a new function type for the given receiver, // receiver type parameters, type parameters, parameters, and results. If // variadic is set, params must hold at least one parameter and the last // parameter's core type must be of unnamed slice or bytestring type. // If recv is non-nil, typeParams must be empty. If recvTypeParams is // non-empty, recv must be non-nil. func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature { if variadic { n := params.Len() if n == 0 { panic("variadic function must have at least one parameter") } core := coreString(params.At(n - 1).typ) if _, ok := core.(*Slice); !ok && !isString(core) { panic(fmt.Sprintf("got %s, want variadic parameter with unnamed slice type or string as core type", core.String())) } } sig := &Signature{recv: recv, params: params, results: results, variadic: variadic} if len(recvTypeParams) != 0 { if recv == nil { panic("function with receiver type parameters must have a receiver") } sig.rparams = bindTParams(recvTypeParams) } if len(typeParams) != 0 { if recv != nil { panic("function with type parameters cannot have a receiver") } sig.tparams = bindTParams(typeParams) } return sig } // Recv returns the receiver of signature s (if a method), or nil if a // function. It is ignored when comparing signatures for identity. // // For an abstract method, Recv returns the enclosing interface either // as a *Named or an *Interface. Due to embedding, an interface may // contain methods whose receiver type is a different interface. func (s *Signature) Recv() *Var { return s.recv } // TypeParams returns the type parameters of signature s, or nil. func (s *Signature) TypeParams() *TypeParamList { return s.tparams } // SetTypeParams sets the type parameters of signature s. func (s *Signature) SetTypeParams(tparams []*TypeParam) { s.tparams = bindTParams(tparams) } // RecvTypeParams returns the receiver type parameters of signature s, or nil. func (s *Signature) RecvTypeParams() *TypeParamList { return s.rparams } // Params returns the parameters of signature s, or nil. func (s *Signature) Params() *Tuple { return s.params } // Results returns the results of signature s, or nil. func (s *Signature) Results() *Tuple { return s.results } // Variadic reports whether the signature s is variadic. func (s *Signature) Variadic() bool { return s.variadic } func (s *Signature) Underlying() Type { return s } func (s *Signature) String() string { return TypeString(s, nil) } // ---------------------------------------------------------------------------- // Implementation // funcType type-checks a function or method type. func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []*syntax.Field, ftyp *syntax.FuncType) { check.openScope(ftyp, "function") check.scope.isFunc = true check.recordScope(ftyp, check.scope) sig.scope = check.scope defer check.closeScope() if recvPar != nil { // collect generic receiver type parameters, if any // - a receiver type parameter is like any other type parameter, except that it is declared implicitly // - the receiver specification acts as local declaration for its type parameters, which may be blank _, rname, rparams := check.unpackRecv(recvPar.Type, true) if len(rparams) > 0 { // The scope of the type parameter T in "func (r T[T]) f()" // starts after f, not at "r"; see #52038. scopePos := ftyp.Pos() tparams := make([]*TypeParam, len(rparams)) for i, rparam := range rparams { tparams[i] = check.declareTypeParam(rparam, scopePos) } sig.rparams = bindTParams(tparams) // Blank identifiers don't get declared, so naive type-checking of the // receiver type expression would fail in Checker.collectParams below, // when Checker.ident cannot resolve the _ to a type. // // Checker.recvTParamMap maps these blank identifiers to their type parameter // types, so that they may be resolved in Checker.ident when they fail // lookup in the scope. for i, p := range rparams { if p.Value == "_" { if check.recvTParamMap == nil { check.recvTParamMap = make(map[*syntax.Name]*TypeParam) } check.recvTParamMap[p] = tparams[i] } } // determine receiver type to get its type parameters // and the respective type parameter bounds var recvTParams []*TypeParam if rname != nil { // recv should be a Named type (otherwise an error is reported elsewhere) // Also: Don't report an error via genericType since it will be reported // again when we type-check the signature. // TODO(gri) maybe the receiver should be marked as invalid instead? if recv := asNamed(check.genericType(rname, nil)); recv != nil { recvTParams = recv.TypeParams().list() } } // provide type parameter bounds if len(tparams) == len(recvTParams) { smap := makeRenameMap(recvTParams, tparams) for i, tpar := range tparams { recvTPar := recvTParams[i] check.mono.recordCanon(tpar, recvTPar) // recvTPar.bound is (possibly) parameterized in the context of the // receiver type declaration. Substitute parameters for the current // context. tpar.bound = check.subst(tpar.obj.pos, recvTPar.bound, smap, nil, check.context()) } } else if len(tparams) < len(recvTParams) { // Reporting an error here is a stop-gap measure to avoid crashes in the // compiler when a type parameter/argument cannot be inferred later. It // may lead to follow-on errors (see issues go.dev/issue/51339, go.dev/issue/51343). // TODO(gri) find a better solution got := measure(len(tparams), "type parameter") check.errorf(recvPar, BadRecv, "got %s, but receiver base type declares %d", got, len(recvTParams)) } } } if tparams != nil { // The parser will complain about invalid type parameters for methods. check.collectTypeParams(&sig.tparams, tparams) } // Use a temporary scope for all parameter declarations and then // squash that scope into the parent scope (and report any // redeclarations at that time). // // TODO(adonovan): now that each declaration has the correct // scopePos, there should be no need for scope squashing. // Audit to ensure all lookups honor scopePos and simplify. scope := NewScope(check.scope, nopos, nopos, "function body (temp. scope)") scopePos := syntax.EndPos(ftyp) // all parameters' scopes start after the signature var recvList []*Var // TODO(gri) remove the need for making a list here if recvPar != nil { recvList, _ = check.collectParams(scope, []*syntax.Field{recvPar}, false, scopePos) // use rewritten receiver type, if any } params, variadic := check.collectParams(scope, ftyp.ParamList, true, scopePos) results, _ := check.collectParams(scope, ftyp.ResultList, false, scopePos) scope.Squash(func(obj, alt Object) { var err error_ err.code = DuplicateDecl err.errorf(obj, "%s redeclared in this block", obj.Name()) err.recordAltDecl(alt) check.report(&err) }) if recvPar != nil { // recv parameter list present (may be empty) // spec: "The receiver is specified via an extra parameter section preceding the // method name. That parameter section must declare a single parameter, the receiver." var recv *Var switch len(recvList) { case 0: // error reported by resolver recv = NewParam(nopos, nil, "", Typ[Invalid]) // ignore recv below default: // more than one receiver check.error(recvList[len(recvList)-1].Pos(), InvalidRecv, "method must have exactly one receiver") fallthrough // continue with first receiver case 1: recv = recvList[0] } sig.recv = recv // Delay validation of receiver type as it may cause premature expansion // of types the receiver type is dependent on (see issues go.dev/issue/51232, go.dev/issue/51233). check.later(func() { // spec: "The receiver type must be of the form T or *T where T is a type name." rtyp, _ := deref(recv.typ) atyp := Unalias(rtyp) if !isValid(atyp) { return // error was reported before } // spec: "The type denoted by T is called the receiver base type; it must not // be a pointer or interface type and it must be declared in the same package // as the method." switch T := atyp.(type) { case *Named: // The receiver type may be an instantiated type referred to // by an alias (which cannot have receiver parameters for now). if T.TypeArgs() != nil && sig.RecvTypeParams() == nil { check.errorf(recv, InvalidRecv, "cannot define new methods on instantiated type %s", rtyp) break } if T.obj.pkg != check.pkg { check.errorf(recv, InvalidRecv, "cannot define new methods on non-local type %s", rtyp) break } var cause string switch u := T.under().(type) { case *Basic: // unsafe.Pointer is treated like a regular pointer if u.kind == UnsafePointer { cause = "unsafe.Pointer" } case *Pointer, *Interface: cause = "pointer or interface type" case *TypeParam: // The underlying type of a receiver base type cannot be a // type parameter: "type T[P any] P" is not a valid declaration. unreachable() } if cause != "" { check.errorf(recv, InvalidRecv, "invalid receiver type %s (%s)", rtyp, cause) } case *Basic: check.errorf(recv, InvalidRecv, "cannot define new methods on non-local type %s", rtyp) default: check.errorf(recv, InvalidRecv, "invalid receiver type %s", recv.typ) } }).describef(recv, "validate receiver %s", recv) } sig.params = NewTuple(params...) sig.results = NewTuple(results...) sig.variadic = variadic } // collectParams declares the parameters of list in scope and returns the corresponding // variable list. func (check *Checker) collectParams(scope *Scope, list []*syntax.Field, variadicOk bool, scopePos syntax.Pos) (params []*Var, variadic bool) { if list == nil { return } var named, anonymous bool var typ Type var prev syntax.Expr for i, field := range list { ftype := field.Type // type-check type of grouped fields only once if ftype != prev { prev = ftype if t, _ := ftype.(*syntax.DotsType); t != nil { ftype = t.Elem if variadicOk && i == len(list)-1 { variadic = true } else { check.softErrorf(t, MisplacedDotDotDot, "can only use ... with final parameter in list") // ignore ... and continue } } typ = check.varType(ftype) } // The parser ensures that f.Tag is nil and we don't // care if a constructed AST contains a non-nil tag. if field.Name != nil { // named parameter name := field.Name.Value if name == "" { check.error(field.Name, InvalidSyntaxTree, "anonymous parameter") // ok to continue } par := NewParam(field.Name.Pos(), check.pkg, name, typ) check.declare(scope, field.Name, par, scopePos) params = append(params, par) named = true } else { // anonymous parameter par := NewParam(field.Pos(), check.pkg, "", typ) check.recordImplicit(field, par) params = append(params, par) anonymous = true } } if named && anonymous { check.error(list[0], InvalidSyntaxTree, "list contains both named and anonymous parameters") // ok to continue } // For a variadic function, change the last parameter's type from T to []T. // Since we type-checked T rather than ...T, we also need to retro-actively // record the type for ...T. if variadic { last := params[len(params)-1] last.typ = &Slice{elem: last.typ} check.recordTypeAndValue(list[len(list)-1].Type, typexpr, last.typ, nil) } return } PK ! *�:# :# conversions.gonu �[��� // Copyright 2012 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. // This file implements typechecking of conversions. package types2 import ( "go/constant" . "internal/types/errors" "unicode" ) // conversion type-checks the conversion T(x). // The result is in x. func (check *Checker) conversion(x *operand, T Type) { constArg := x.mode == constant_ constConvertibleTo := func(T Type, val *constant.Value) bool { switch t, _ := under(T).(*Basic); { case t == nil: // nothing to do case representableConst(x.val, check, t, val): return true case isInteger(x.typ) && isString(t): codepoint := unicode.ReplacementChar if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune { codepoint = rune(i) } if val != nil { *val = constant.MakeString(string(codepoint)) } return true } return false } var ok bool var cause string switch { case constArg && isConstType(T): // constant conversion ok = constConvertibleTo(T, &x.val) // A conversion from an integer constant to an integer type // can only fail if there's overflow. Give a concise error. // (go.dev/issue/63563) if !ok && isInteger(x.typ) && isInteger(T) { check.errorf(x, InvalidConversion, "constant %s overflows %s", x.val, T) x.mode = invalid return } case constArg && isTypeParam(T): // x is convertible to T if it is convertible // to each specific type in the type set of T. // If T's type set is empty, or if it doesn't // have specific types, constant x cannot be // converted. ok = T.(*TypeParam).underIs(func(u Type) bool { // u is nil if there are no specific type terms if u == nil { cause = check.sprintf("%s does not contain specific types", T) return false } if isString(x.typ) && isBytesOrRunes(u) { return true } if !constConvertibleTo(u, nil) { if isInteger(x.typ) && isInteger(u) { // see comment above on constant conversion cause = check.sprintf("constant %s overflows %s (in %s)", x.val, u, T) } else { cause = check.sprintf("cannot convert %s to type %s (in %s)", x, u, T) } return false } return true }) x.mode = value // type parameters are not constants case x.convertibleTo(check, T, &cause): // non-constant conversion ok = true x.mode = value } if !ok { if cause != "" { check.errorf(x, InvalidConversion, "cannot convert %s to type %s: %s", x, T, cause) } else { check.errorf(x, InvalidConversion, "cannot convert %s to type %s", x, T) } x.mode = invalid return } // The conversion argument types are final. For untyped values the // conversion provides the type, per the spec: "A constant may be // given a type explicitly by a constant declaration or conversion,...". if isUntyped(x.typ) { final := T // - For conversions to interfaces, except for untyped nil arguments, // use the argument's default type. // - For conversions of untyped constants to non-constant types, also // use the default type (e.g., []byte("foo") should report string // not []byte as type for the constant "foo"). // - For constant integer to string conversions, keep the argument type. // (See also the TODO below.) if x.typ == Typ[UntypedNil] { // ok } else if isNonTypeParamInterface(T) || constArg && !isConstType(T) { final = Default(x.typ) } else if x.mode == constant_ && isInteger(x.typ) && allString(T) { final = x.typ } check.updateExprType(x.expr, final, true) } x.typ = T } // TODO(gri) convertibleTo checks if T(x) is valid. It assumes that the type // of x is fully known, but that's not the case for say string(1<<s + 1.0): // Here, the type of 1<<s + 1.0 will be UntypedFloat which will lead to the // (correct!) refusal of the conversion. But the reported error is essentially // "cannot convert untyped float value to string", yet the correct error (per // the spec) is that we cannot shift a floating-point value: 1 in 1<<s should // be converted to UntypedFloat because of the addition of 1.0. Fixing this // is tricky because we'd have to run updateExprType on the argument first. // (go.dev/issue/21982.) // convertibleTo reports whether T(x) is valid. In the failure case, *cause // may be set to the cause for the failure. // The check parameter may be nil if convertibleTo is invoked through an // exported API call, i.e., when all methods have been type-checked. func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // "x is assignable to T" if ok, _ := x.assignableTo(check, T, cause); ok { return true } // "V and T have identical underlying types if tags are ignored // and V and T are not type parameters" V := x.typ Vu := under(V) Tu := under(T) Vp, _ := V.(*TypeParam) Tp, _ := T.(*TypeParam) if IdenticalIgnoreTags(Vu, Tu) && Vp == nil && Tp == nil { return true } // "V and T are unnamed pointer types and their pointer base types // have identical underlying types if tags are ignored // and their pointer base types are not type parameters" if V, ok := V.(*Pointer); ok { if T, ok := T.(*Pointer); ok { if IdenticalIgnoreTags(under(V.base), under(T.base)) && !isTypeParam(V.base) && !isTypeParam(T.base) { return true } } } // "V and T are both integer or floating point types" if isIntegerOrFloat(Vu) && isIntegerOrFloat(Tu) { return true } // "V and T are both complex types" if isComplex(Vu) && isComplex(Tu) { return true } // "V is an integer or a slice of bytes or runes and T is a string type" if (isInteger(Vu) || isBytesOrRunes(Vu)) && isString(Tu) { return true } // "V is a string and T is a slice of bytes or runes" if isString(Vu) && isBytesOrRunes(Tu) { return true } // package unsafe: // "any pointer or value of underlying type uintptr can be converted into a unsafe.Pointer" if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(Tu) { return true } // "and vice versa" if isUnsafePointer(Vu) && (isPointer(Tu) || isUintptr(Tu)) { return true } // "V is a slice, T is an array or pointer-to-array type, // and the slice and array types have identical element types." if s, _ := Vu.(*Slice); s != nil { switch a := Tu.(type) { case *Array: if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, x, go1_20) { return true } // check != nil if cause != nil { // TODO(gri) consider restructuring versionErrorf so we can use it here and below *cause = "conversion of slices to arrays requires go1.20 or later" } return false } case *Pointer: if a, _ := under(a.Elem()).(*Array); a != nil { if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, x, go1_17) { return true } // check != nil if cause != nil { *cause = "conversion of slices to array pointers requires go1.17 or later" } return false } } } } // optimization: if we don't have type parameters, we're done if Vp == nil && Tp == nil { return false } errorf := func(format string, args ...interface{}) { if check != nil && cause != nil { msg := check.sprintf(format, args...) if *cause != "" { msg += "\n\t" + *cause } *cause = msg } } // generic cases with specific type terms // (generic operands cannot be constants, so we can ignore x.val) switch { case Vp != nil && Tp != nil: x := *x // don't clobber outer x return Vp.is(func(V *term) bool { if V == nil { return false // no specific types } x.typ = V.typ return Tp.is(func(T *term) bool { if T == nil { return false // no specific types } if !x.convertibleTo(check, T.typ, cause) { errorf("cannot convert %s (in %s) to type %s (in %s)", V.typ, Vp, T.typ, Tp) return false } return true }) }) case Vp != nil: x := *x // don't clobber outer x return Vp.is(func(V *term) bool { if V == nil { return false // no specific types } x.typ = V.typ if !x.convertibleTo(check, T, cause) { errorf("cannot convert %s (in %s) to type %s", V.typ, Vp, T) return false } return true }) case Tp != nil: return Tp.is(func(T *term) bool { if T == nil { return false // no specific types } if !x.convertibleTo(check, T.typ, cause) { errorf("cannot convert %s to type %s (in %s)", x.typ, T.typ, Tp) return false } return true }) } return false } func isUintptr(typ Type) bool { t, _ := under(typ).(*Basic) return t != nil && t.kind == Uintptr } func isUnsafePointer(typ Type) bool { t, _ := under(typ).(*Basic) return t != nil && t.kind == UnsafePointer } func isPointer(typ Type) bool { _, ok := under(typ).(*Pointer) return ok } func isBytesOrRunes(typ Type) bool { if s, _ := under(typ).(*Slice); s != nil { t, _ := under(s.elem).(*Basic) return t != nil && (t.kind == Byte || t.kind == Rune) } return false } PK ! � 5� � chan.gonu �[��� // Copyright 2011 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 types2 // A Chan represents a channel type. type Chan struct { dir ChanDir elem Type } // A ChanDir value indicates a channel direction. type ChanDir int // The direction of a channel is indicated by one of these constants. const ( SendRecv ChanDir = iota SendOnly RecvOnly ) // NewChan returns a new channel type for the given direction and element type. func NewChan(dir ChanDir, elem Type) *Chan { return &Chan{dir: dir, elem: elem} } // Dir returns the direction of channel c. func (c *Chan) Dir() ChanDir { return c.dir } // Elem returns the element type of channel c. func (c *Chan) Elem() Type { return c.elem } func (c *Chan) Underlying() Type { return c } func (c *Chan) String() string { return TypeString(c, nil) } PK ! �J�%�B �B predicates.gonu �[��� // Copyright 2012 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. // This file implements commonly used type predicates. package types2 // isValid reports whether t is a valid type. func isValid(t Type) bool { return Unalias(t) != Typ[Invalid] } // The isX predicates below report whether t is an X. // If t is a type parameter the result is false; i.e., // these predicates don't look inside a type parameter. func isBoolean(t Type) bool { return isBasic(t, IsBoolean) } func isInteger(t Type) bool { return isBasic(t, IsInteger) } func isUnsigned(t Type) bool { return isBasic(t, IsUnsigned) } func isFloat(t Type) bool { return isBasic(t, IsFloat) } func isComplex(t Type) bool { return isBasic(t, IsComplex) } func isNumeric(t Type) bool { return isBasic(t, IsNumeric) } func isString(t Type) bool { return isBasic(t, IsString) } func isIntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) } func isConstType(t Type) bool { return isBasic(t, IsConstType) } // isBasic reports whether under(t) is a basic type with the specified info. // If t is a type parameter the result is false; i.e., // isBasic does not look inside a type parameter. func isBasic(t Type, info BasicInfo) bool { u, _ := under(t).(*Basic) return u != nil && u.info&info != 0 } // The allX predicates below report whether t is an X. // If t is a type parameter the result is true if isX is true // for all specified types of the type parameter's type set. // allX is an optimized version of isX(coreType(t)) (which // is the same as underIs(t, isX)). func allBoolean(t Type) bool { return allBasic(t, IsBoolean) } func allInteger(t Type) bool { return allBasic(t, IsInteger) } func allUnsigned(t Type) bool { return allBasic(t, IsUnsigned) } func allNumeric(t Type) bool { return allBasic(t, IsNumeric) } func allString(t Type) bool { return allBasic(t, IsString) } func allOrdered(t Type) bool { return allBasic(t, IsOrdered) } func allNumericOrString(t Type) bool { return allBasic(t, IsNumeric|IsString) } // allBasic reports whether under(t) is a basic type with the specified info. // If t is a type parameter, the result is true if isBasic(t, info) is true // for all specific types of the type parameter's type set. // allBasic(t, info) is an optimized version of isBasic(coreType(t), info). func allBasic(t Type, info BasicInfo) bool { if tpar, _ := Unalias(t).(*TypeParam); tpar != nil { return tpar.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) }) } return isBasic(t, info) } // hasName reports whether t has a name. This includes // predeclared types, defined types, and type parameters. // hasName may be called with types that are not fully set up. func hasName(t Type) bool { switch Unalias(t).(type) { case *Basic, *Named, *TypeParam: return true } return false } // isTypeLit reports whether t is a type literal. // This includes all non-defined types, but also basic types. // isTypeLit may be called with types that are not fully set up. func isTypeLit(t Type) bool { switch Unalias(t).(type) { case *Named, *TypeParam: return false } return true } // isTyped reports whether t is typed; i.e., not an untyped // constant or boolean. isTyped may be called with types that // are not fully set up. func isTyped(t Type) bool { // Alias or Named types cannot denote untyped types, // thus we don't need to call Unalias or under // (which would be unsafe to do for types that are // not fully set up). b, _ := t.(*Basic) return b == nil || b.info&IsUntyped == 0 } // isUntyped(t) is the same as !isTyped(t). func isUntyped(t Type) bool { return !isTyped(t) } // IsInterface reports whether t is an interface type. func IsInterface(t Type) bool { _, ok := under(t).(*Interface) return ok } // isNonTypeParamInterface reports whether t is an interface type but not a type parameter. func isNonTypeParamInterface(t Type) bool { return !isTypeParam(t) && IsInterface(t) } // isTypeParam reports whether t is a type parameter. func isTypeParam(t Type) bool { _, ok := Unalias(t).(*TypeParam) return ok } // hasEmptyTypeset reports whether t is a type parameter with an empty type set. // The function does not force the computation of the type set and so is safe to // use anywhere, but it may report a false negative if the type set has not been // computed yet. func hasEmptyTypeset(t Type) bool { if tpar, _ := Unalias(t).(*TypeParam); tpar != nil && tpar.bound != nil { iface, _ := safeUnderlying(tpar.bound).(*Interface) return iface != nil && iface.tset != nil && iface.tset.IsEmpty() } return false } // isGeneric reports whether a type is a generic, uninstantiated type // (generic signatures are not included). // TODO(gri) should we include signatures or assert that they are not present? func isGeneric(t Type) bool { // A parameterized type is only generic if it doesn't have an instantiation already. named := asNamed(t) return named != nil && named.obj != nil && named.inst == nil && named.TypeParams().Len() > 0 } // Comparable reports whether values of type T are comparable. func Comparable(T Type) bool { return comparable(T, true, nil, nil) } // If dynamic is set, non-type parameter interfaces are always comparable. // If reportf != nil, it may be used to report why T is not comparable. func comparable(T Type, dynamic bool, seen map[Type]bool, reportf func(string, ...interface{})) bool { if seen[T] { return true } if seen == nil { seen = make(map[Type]bool) } seen[T] = true switch t := under(T).(type) { case *Basic: // assume invalid types to be comparable // to avoid follow-up errors return t.kind != UntypedNil case *Pointer, *Chan: return true case *Struct: for _, f := range t.fields { if !comparable(f.typ, dynamic, seen, nil) { if reportf != nil { reportf("struct containing %s cannot be compared", f.typ) } return false } } return true case *Array: if !comparable(t.elem, dynamic, seen, nil) { if reportf != nil { reportf("%s cannot be compared", t) } return false } return true case *Interface: if dynamic && !isTypeParam(T) || t.typeSet().IsComparable(seen) { return true } if reportf != nil { if t.typeSet().IsEmpty() { reportf("empty type set") } else { reportf("incomparable types in type set") } } // fallthrough } return false } // hasNil reports whether type t includes the nil value. func hasNil(t Type) bool { switch u := under(t).(type) { case *Basic: return u.kind == UnsafePointer case *Slice, *Pointer, *Signature, *Map, *Chan: return true case *Interface: return !isTypeParam(t) || u.typeSet().underIs(func(u Type) bool { return u != nil && hasNil(u) }) } return false } // An ifacePair is a node in a stack of interface type pairs compared for identity. type ifacePair struct { x, y *Interface prev *ifacePair } func (p *ifacePair) identical(q *ifacePair) bool { return p.x == q.x && p.y == q.y || p.x == q.y && p.y == q.x } // A comparer is used to compare types. type comparer struct { ignoreTags bool // if set, identical ignores struct tags ignoreInvalids bool // if set, identical treats an invalid type as identical to any type } // For changes to this code the corresponding changes should be made to unifier.nify. func (c *comparer) identical(x, y Type, p *ifacePair) bool { x = Unalias(x) y = Unalias(y) if x == y { return true } if c.ignoreInvalids && (!isValid(x) || !isValid(y)) { return true } switch x := x.(type) { case *Basic: // Basic types are singletons except for the rune and byte // aliases, thus we cannot solely rely on the x == y check // above. See also comment in TypeName.IsAlias. if y, ok := y.(*Basic); ok { return x.kind == y.kind } case *Array: // Two array types are identical if they have identical element types // and the same array length. if y, ok := y.(*Array); ok { // If one or both array lengths are unknown (< 0) due to some error, // assume they are the same to avoid spurious follow-on errors. return (x.len < 0 || y.len < 0 || x.len == y.len) && c.identical(x.elem, y.elem, p) } case *Slice: // Two slice types are identical if they have identical element types. if y, ok := y.(*Slice); ok { return c.identical(x.elem, y.elem, p) } case *Struct: // Two struct types are identical if they have the same sequence of fields, // and if corresponding fields have the same names, and identical types, // and identical tags. Two embedded fields are considered to have the same // name. Lower-case field names from different packages are always different. if y, ok := y.(*Struct); ok { if x.NumFields() == y.NumFields() { for i, f := range x.fields { g := y.fields[i] if f.embedded != g.embedded || !c.ignoreTags && x.Tag(i) != y.Tag(i) || !f.sameId(g.pkg, g.name) || !c.identical(f.typ, g.typ, p) { return false } } return true } } case *Pointer: // Two pointer types are identical if they have identical base types. if y, ok := y.(*Pointer); ok { return c.identical(x.base, y.base, p) } case *Tuple: // Two tuples types are identical if they have the same number of elements // and corresponding elements have identical types. if y, ok := y.(*Tuple); ok { if x.Len() == y.Len() { if x != nil { for i, v := range x.vars { w := y.vars[i] if !c.identical(v.typ, w.typ, p) { return false } } } return true } } case *Signature: y, _ := y.(*Signature) if y == nil { return false } // Two function types are identical if they have the same number of // parameters and result values, corresponding parameter and result types // are identical, and either both functions are variadic or neither is. // Parameter and result names are not required to match, and type // parameters are considered identical modulo renaming. if x.TypeParams().Len() != y.TypeParams().Len() { return false } // In the case of generic signatures, we will substitute in yparams and // yresults. yparams := y.params yresults := y.results if x.TypeParams().Len() > 0 { // We must ignore type parameter names when comparing x and y. The // easiest way to do this is to substitute x's type parameters for y's. xtparams := x.TypeParams().list() ytparams := y.TypeParams().list() var targs []Type for i := range xtparams { targs = append(targs, x.TypeParams().At(i)) } smap := makeSubstMap(ytparams, targs) var check *Checker // ok to call subst on a nil *Checker ctxt := NewContext() // need a non-nil Context for the substitution below // Constraints must be pair-wise identical, after substitution. for i, xtparam := range xtparams { ybound := check.subst(nopos, ytparams[i].bound, smap, nil, ctxt) if !c.identical(xtparam.bound, ybound, p) { return false } } yparams = check.subst(nopos, y.params, smap, nil, ctxt).(*Tuple) yresults = check.subst(nopos, y.results, smap, nil, ctxt).(*Tuple) } return x.variadic == y.variadic && c.identical(x.params, yparams, p) && c.identical(x.results, yresults, p) case *Union: if y, _ := y.(*Union); y != nil { // TODO(rfindley): can this be reached during type checking? If so, // consider passing a type set map. unionSets := make(map[*Union]*_TypeSet) xset := computeUnionTypeSet(nil, unionSets, nopos, x) yset := computeUnionTypeSet(nil, unionSets, nopos, y) return xset.terms.equal(yset.terms) } case *Interface: // Two interface types are identical if they describe the same type sets. // With the existing implementation restriction, this simplifies to: // // Two interface types are identical if they have the same set of methods with // the same names and identical function types, and if any type restrictions // are the same. Lower-case method names from different packages are always // different. The order of the methods is irrelevant. if y, ok := y.(*Interface); ok { xset := x.typeSet() yset := y.typeSet() if xset.comparable != yset.comparable { return false } if !xset.terms.equal(yset.terms) { return false } a := xset.methods b := yset.methods if len(a) == len(b) { // Interface types are the only types where cycles can occur // that are not "terminated" via named types; and such cycles // can only be created via method parameter types that are // anonymous interfaces (directly or indirectly) embedding // the current interface. Example: // // type T interface { // m() interface{T} // } // // If two such (differently named) interfaces are compared, // endless recursion occurs if the cycle is not detected. // // If x and y were compared before, they must be equal // (if they were not, the recursion would have stopped); // search the ifacePair stack for the same pair. // // This is a quadratic algorithm, but in practice these stacks // are extremely short (bounded by the nesting depth of interface // type declarations that recur via parameter types, an extremely // rare occurrence). An alternative implementation might use a // "visited" map, but that is probably less efficient overall. q := &ifacePair{x, y, p} for p != nil { if p.identical(q) { return true // same pair was compared before } p = p.prev } if debug { assertSortedMethods(a) assertSortedMethods(b) } for i, f := range a { g := b[i] if f.Id() != g.Id() || !c.identical(f.typ, g.typ, q) { return false } } return true } } case *Map: // Two map types are identical if they have identical key and value types. if y, ok := y.(*Map); ok { return c.identical(x.key, y.key, p) && c.identical(x.elem, y.elem, p) } case *Chan: // Two channel types are identical if they have identical value types // and the same direction. if y, ok := y.(*Chan); ok { return x.dir == y.dir && c.identical(x.elem, y.elem, p) } case *Named: // Two named types are identical if their type names originate // in the same type declaration; if they are instantiated they // must have identical type argument lists. if y := asNamed(y); y != nil { // check type arguments before origins to match unifier // (for correct source code we need to do all checks so // order doesn't matter) xargs := x.TypeArgs().list() yargs := y.TypeArgs().list() if len(xargs) != len(yargs) { return false } for i, xarg := range xargs { if !Identical(xarg, yargs[i]) { return false } } return identicalOrigin(x, y) } case *TypeParam: // nothing to do (x and y being equal is caught in the very beginning of this function) case nil: // avoid a crash in case of nil type default: unreachable() } return false } // identicalOrigin reports whether x and y originated in the same declaration. func identicalOrigin(x, y *Named) bool { // TODO(gri) is this correct? return x.Origin().obj == y.Origin().obj } // identicalInstance reports if two type instantiations are identical. // Instantiations are identical if their origin and type arguments are // identical. func identicalInstance(xorig Type, xargs []Type, yorig Type, yargs []Type) bool { if len(xargs) != len(yargs) { return false } for i, xa := range xargs { if !Identical(xa, yargs[i]) { return false } } return Identical(xorig, yorig) } // Default returns the default "typed" type for an "untyped" type; // it returns the incoming type for all other types. The default type // for untyped nil is untyped nil. func Default(t Type) Type { if t, ok := Unalias(t).(*Basic); ok { switch t.kind { case UntypedBool: return Typ[Bool] case UntypedInt: return Typ[Int] case UntypedRune: return universeRune // use 'rune' name case UntypedFloat: return Typ[Float64] case UntypedComplex: return Typ[Complex128] case UntypedString: return Typ[String] } } return t } // maxType returns the "largest" type that encompasses both x and y. // If x and y are different untyped numeric types, the result is the type of x or y // that appears later in this list: integer, rune, floating-point, complex. // Otherwise, if x != y, the result is nil. func maxType(x, y Type) Type { // We only care about untyped types (for now), so == is good enough. // TODO(gri) investigate generalizing this function to simplify code elsewhere if x == y { return x } if isUntyped(x) && isUntyped(y) && isNumeric(x) && isNumeric(y) { // untyped types are basic types if x.(*Basic).kind > y.(*Basic).kind { return x } return y } return nil } // clone makes a "flat copy" of *p and returns a pointer to the copy. func clone[P *T, T any](p P) P { c := *p return &c } PK ! X1z�� � typeparam.gonu �[��� // Copyright 2011 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 types2 import "sync/atomic" // Note: This is a uint32 rather than a uint64 because the // respective 64 bit atomic instructions are not available // on all platforms. var lastID atomic.Uint32 // nextID returns a value increasing monotonically by 1 with // each call, starting with 1. It may be called concurrently. func nextID() uint64 { return uint64(lastID.Add(1)) } // A TypeParam represents a type parameter type. type TypeParam struct { check *Checker // for lazy type bound completion id uint64 // unique id, for debugging only obj *TypeName // corresponding type name index int // type parameter index in source order, starting at 0 bound Type // any type, but underlying is eventually *Interface for correct programs (see TypeParam.iface) } // NewTypeParam returns a new TypeParam. Type parameters may be set on a Named // or Signature type by calling SetTypeParams. Setting a type parameter on more // than one type will result in a panic. // // The constraint argument can be nil, and set later via SetConstraint. If the // constraint is non-nil, it must be fully defined. func NewTypeParam(obj *TypeName, constraint Type) *TypeParam { return (*Checker)(nil).newTypeParam(obj, constraint) } // check may be nil func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam { // Always increment lastID, even if it is not used. id := nextID() if check != nil { check.nextID++ id = check.nextID } typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint} if obj.typ == nil { obj.typ = typ } // iface may mutate typ.bound, so we must ensure that iface() is called // at least once before the resulting TypeParam escapes. if check != nil { check.needsCleanup(typ) } else if constraint != nil { typ.iface() } return typ } // Obj returns the type name for the type parameter t. func (t *TypeParam) Obj() *TypeName { return t.obj } // Index returns the index of the type param within its param list, or -1 if // the type parameter has not yet been bound to a type. func (t *TypeParam) Index() int { return t.index } // Constraint returns the type constraint specified for t. func (t *TypeParam) Constraint() Type { return t.bound } // SetConstraint sets the type constraint for t. // // It must be called by users of NewTypeParam after the bound's underlying is // fully defined, and before using the type parameter in any way other than to // form other types. Once SetConstraint returns the receiver, t is safe for // concurrent use. func (t *TypeParam) SetConstraint(bound Type) { if bound == nil { panic("nil constraint") } t.bound = bound // iface may mutate t.bound (if bound is not an interface), so ensure that // this is done before returning. t.iface() } func (t *TypeParam) Underlying() Type { return t.iface() } func (t *TypeParam) String() string { return TypeString(t, nil) } // ---------------------------------------------------------------------------- // Implementation func (t *TypeParam) cleanup() { t.iface() t.check = nil } // iface returns the constraint interface of t. func (t *TypeParam) iface() *Interface { bound := t.bound // determine constraint interface var ityp *Interface switch u := under(bound).(type) { case *Basic: if !isValid(u) { // error is reported elsewhere return &emptyInterface } case *Interface: if isTypeParam(bound) { // error is reported in Checker.collectTypeParams return &emptyInterface } ityp = u } // If we don't have an interface, wrap constraint into an implicit interface. if ityp == nil { ityp = NewInterfaceType(nil, []Type{bound}) ityp.implicit = true t.bound = ityp // update t.bound for next time (optimization) } // compute type set if necessary if ityp.tset == nil { // pos is used for tracing output; start with the type parameter position. pos := t.obj.pos // use the (original or possibly instantiated) type bound position if we have one if n := asNamed(bound); n != nil { pos = n.obj.pos } computeInterfaceTypeSet(t.check, pos, ityp) } return ityp } // is calls f with the specific type terms of t's constraint and reports whether // all calls to f returned true. If there are no specific terms, is // returns the result of f(nil). func (t *TypeParam) is(f func(*term) bool) bool { return t.iface().typeSet().is(f) } // underIs calls f with the underlying types of the specific type terms // of t's constraint and reports whether all calls to f returned true. // If there are no specific terms, underIs returns the result of f(nil). func (t *TypeParam) underIs(f func(Type) bool) bool { return t.iface().typeSet().underIs(f) } PK ! �� �# �# validtype.gonu �[��� // Copyright 2022 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 types2 // validType verifies that the given type does not "expand" indefinitely // producing a cycle in the type graph. // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) func (check *Checker) validType(typ *Named) { check.validType0(typ, nil, nil) } // validType0 checks if the given type is valid. If typ is a type parameter // its value is looked up in the type argument list of the instantiated // (enclosing) type, if it exists. Otherwise the type parameter must be from // an enclosing function and can be ignored. // The nest list describes the stack (the "nest in memory") of types which // contain (or embed in the case of interfaces) other types. For instance, a // struct named S which contains a field of named type F contains (the memory // of) F in S, leading to the nest S->F. If a type appears in its own nest // (say S->F->S) we have an invalid recursive type. The path list is the full // path of named types in a cycle, it is only needed for error reporting. func (check *Checker) validType0(typ Type, nest, path []*Named) bool { switch t := Unalias(typ).(type) { case nil: // We should never see a nil type but be conservative and panic // only in debug mode. if debug { panic("validType0(nil)") } case *Array: return check.validType0(t.elem, nest, path) case *Struct: for _, f := range t.fields { if !check.validType0(f.typ, nest, path) { return false } } case *Union: for _, t := range t.terms { if !check.validType0(t.typ, nest, path) { return false } } case *Interface: for _, etyp := range t.embeddeds { if !check.validType0(etyp, nest, path) { return false } } case *Named: // Exit early if we already know t is valid. // This is purely an optimization but it prevents excessive computation // times in pathological cases such as testdata/fixedbugs/issue6977.go. // (Note: The valids map could also be allocated locally, once for each // validType call.) if check.valids.lookup(t) != nil { break } // Don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). // Note: ensure that t.orig is fully resolved by calling Underlying(). if !isValid(t.Underlying()) { return false } // If the current type t is also found in nest, (the memory of) t is // embedded in itself, indicating an invalid recursive type. for _, e := range nest { if Identical(e, t) { // We have a cycle. If t != t.Origin() then t is an instance of // the generic type t.Origin(). Because t is in the nest, t must // occur within the definition (RHS) of the generic type t.Origin(), // directly or indirectly, after expansion of the RHS. // Therefore t.Origin() must be invalid, no matter how it is // instantiated since the instantiation t of t.Origin() happens // inside t.Origin()'s RHS and thus is always the same and always // present. // Therefore we can mark the underlying of both t and t.Origin() // as invalid. If t is not an instance of a generic type, t and // t.Origin() are the same. // Furthermore, because we check all types in a package for validity // before type checking is complete, any exported type that is invalid // will have an invalid underlying type and we can't reach here with // such a type (invalid types are excluded above). // Thus, if we reach here with a type t, both t and t.Origin() (if // different in the first place) must be from the current package; // they cannot have been imported. // Therefore it is safe to change their underlying types; there is // no chance for a race condition (the types of the current package // are not yet available to other goroutines). assert(t.obj.pkg == check.pkg) assert(t.Origin().obj.pkg == check.pkg) t.underlying = Typ[Invalid] t.Origin().underlying = Typ[Invalid] // Find the starting point of the cycle and report it. // Because each type in nest must also appear in path (see invariant below), // type t must be in path since it was found in nest. But not every type in path // is in nest. Specifically t may appear in path with an earlier index than the // index of t in nest. Search again. for start, p := range path { if Identical(p, t) { check.cycleError(makeObjList(path[start:])) return false } } panic("cycle start not found") } } // No cycle was found. Check the RHS of t. // Every type added to nest is also added to path; thus every type that is in nest // must also be in path (invariant). But not every type in path is in nest, since // nest may be pruned (see below, *TypeParam case). if !check.validType0(t.Origin().fromRHS, append(nest, t), append(path, t)) { return false } check.valids.add(t) // t is valid case *TypeParam: // A type parameter stands for the type (argument) it was instantiated with. // Check the corresponding type argument for validity if we are in an // instantiated type. if len(nest) > 0 { inst := nest[len(nest)-1] // the type instance // Find the corresponding type argument for the type parameter // and proceed with checking that type argument. for i, tparam := range inst.TypeParams().list() { // The type parameter and type argument lists should // match in length but be careful in case of errors. if t == tparam && i < inst.TypeArgs().Len() { targ := inst.TypeArgs().At(i) // The type argument must be valid in the enclosing // type (where inst was instantiated), hence we must // check targ's validity in the type nest excluding // the current (instantiated) type (see the example // at the end of this file). // For error reporting we keep the full path. return check.validType0(targ, nest[:len(nest)-1], path) } } } } return true } // makeObjList returns the list of type name objects for the given // list of named types. func makeObjList(tlist []*Named) []Object { olist := make([]Object, len(tlist)) for i, t := range tlist { olist[i] = t.obj } return olist } // Here is an example illustrating why we need to exclude the // instantiated type from nest when evaluating the validity of // a type parameter. Given the declarations // // var _ A[A[string]] // // type A[P any] struct { _ B[P] } // type B[P any] struct { _ P } // // we want to determine if the type A[A[string]] is valid. // We start evaluating A[A[string]] outside any type nest: // // A[A[string]] // nest = // path = // // The RHS of A is now evaluated in the A[A[string]] nest: // // struct{_ B[P₁]} // nest = A[A[string]] // path = A[A[string]] // // The struct has a single field of type B[P₁] with which // we continue: // // B[P₁] // nest = A[A[string]] // path = A[A[string]] // // struct{_ P₂} // nest = A[A[string]]->B[P] // path = A[A[string]]->B[P] // // Eventually we reach the type parameter P of type B (P₂): // // P₂ // nest = A[A[string]]->B[P] // path = A[A[string]]->B[P] // // The type argument for P of B is the type parameter P of A (P₁). // It must be evaluated in the type nest that existed when B was // instantiated: // // P₁ // nest = A[A[string]] <== type nest at B's instantiation time // path = A[A[string]]->B[P] // // If we'd use the current nest it would correspond to the path // which will be wrong as we will see shortly. P's type argument // is A[string], which again must be evaluated in the type nest // that existed when A was instantiated with A[string]. That type // nest is empty: // // A[string] // nest = <== type nest at A's instantiation time // path = A[A[string]]->B[P] // // Evaluation then proceeds as before for A[string]: // // struct{_ B[P₁]} // nest = A[string] // path = A[A[string]]->B[P]->A[string] // // Now we reach B[P] again. If we had not adjusted nest, it would // correspond to path, and we would find B[P] in nest, indicating // a cycle, which would clearly be wrong since there's no cycle in // A[string]: // // B[P₁] // nest = A[string] // path = A[A[string]]->B[P]->A[string] <== path contains B[P]! // // But because we use the correct type nest, evaluation proceeds without // errors and we get the evaluation sequence: // // struct{_ P₂} // nest = A[string]->B[P] // path = A[A[string]]->B[P]->A[string]->B[P] // P₂ // nest = A[string]->B[P] // path = A[A[string]]->B[P]->A[string]->B[P] // P₁ // nest = A[string] // path = A[A[string]]->B[P]->A[string]->B[P] // string // nest = // path = A[A[string]]->B[P]->A[string]->B[P] // // At this point we're done and A[A[string]] and is valid. PK ! �c!�� � typeset_test.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" "strings" "testing" ) func TestInvalidTypeSet(t *testing.T) { if !invalidTypeSet.IsEmpty() { t.Error("invalidTypeSet is not empty") } } func TestTypeSetString(t *testing.T) { for body, want := range map[string]string{ "{}": "𝓤", "{int}": "{int}", "{~int}": "{~int}", "{int|string}": "{int | string}", "{int; string}": "∅", "{comparable}": "{comparable}", "{comparable; int}": "{int}", "{~int; comparable}": "{~int}", "{int|string; comparable}": "{int | string}", "{comparable; int; string}": "∅", "{m()}": "{func (p.T).m()}", "{m1(); m2() int }": "{func (p.T).m1(); func (p.T).m2() int}", "{error}": "{func (error).Error() string}", "{m(); comparable}": "{comparable; func (p.T).m()}", "{m1(); comparable; m2() int }": "{comparable; func (p.T).m1(); func (p.T).m2() int}", "{comparable; error}": "{comparable; func (error).Error() string}", "{m(); comparable; int|float32|string}": "{func (p.T).m(); int | float32 | string}", "{m1(); int; m2(); comparable }": "{func (p.T).m1(); func (p.T).m2(); int}", "{E}; type E interface{}": "𝓤", "{E}; type E interface{int;string}": "∅", "{E}; type E interface{comparable}": "{comparable}", } { // parse errh := func(error) {} // dummy error handler so that parsing continues in presence of errors src := "package p; type T interface" + body file, err := syntax.Parse(nil, strings.NewReader(src), errh, nil, 0) if err != nil { t.Fatalf("%s: %v (invalid test case)", body, err) } // type check var conf Config pkg, err := conf.Check(file.PkgName.Value, []*syntax.File{file}, nil) if err != nil { t.Fatalf("%s: %v (invalid test case)", body, err) } // lookup T obj := pkg.scope.Lookup("T") if obj == nil { t.Fatalf("%s: T not found (invalid test case)", body) } T, ok := under(obj.Type()).(*Interface) if !ok { t.Fatalf("%s: %v is not an interface (invalid test case)", body, obj) } // verify test case got := T.typeSet().String() if got != want { t.Errorf("%s: got %s; want %s", body, got, want) } } } // TODO(gri) add more tests PK ! C�Ke$ e$ mono.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" . "internal/types/errors" ) // This file implements a check to validate that a Go package doesn't // have unbounded recursive instantiation, which is not compatible // with compilers using static instantiation (such as // monomorphization). // // It implements a sort of "type flow" analysis by detecting which // type parameters are instantiated with other type parameters (or // types derived thereof). A package cannot be statically instantiated // if the graph has any cycles involving at least one derived type. // // Concretely, we construct a directed, weighted graph. Vertices are // used to represent type parameters as well as some defined // types. Edges are used to represent how types depend on each other: // // * Everywhere a type-parameterized function or type is instantiated, // we add edges to each type parameter from the vertices (if any) // representing each type parameter or defined type referenced by // the type argument. If the type argument is just the referenced // type itself, then the edge has weight 0, otherwise 1. // // * For every defined type declared within a type-parameterized // function or method, we add an edge of weight 1 to the defined // type from each ambient type parameter. // // For example, given: // // func f[A, B any]() { // type T int // f[T, map[A]B]() // } // // we construct vertices representing types A, B, and T. Because of // declaration "type T int", we construct edges T<-A and T<-B with // weight 1; and because of instantiation "f[T, map[A]B]" we construct // edges A<-T with weight 0, and B<-A and B<-B with weight 1. // // Finally, we look for any positive-weight cycles. Zero-weight cycles // are allowed because static instantiation will reach a fixed point. type monoGraph struct { vertices []monoVertex edges []monoEdge // canon maps method receiver type parameters to their respective // receiver type's type parameters. canon map[*TypeParam]*TypeParam // nameIdx maps a defined type or (canonical) type parameter to its // vertex index. nameIdx map[*TypeName]int } type monoVertex struct { weight int // weight of heaviest known path to this vertex pre int // previous edge (if any) in the above path len int // length of the above path // obj is the defined type or type parameter represented by this // vertex. obj *TypeName } type monoEdge struct { dst, src int weight int pos syntax.Pos typ Type } func (check *Checker) monomorph() { // We detect unbounded instantiation cycles using a variant of // Bellman-Ford's algorithm. Namely, instead of always running |V| // iterations, we run until we either reach a fixed point or we've // found a path of length |V|. This allows us to terminate earlier // when there are no cycles, which should be the common case. again := true for again { again = false for i, edge := range check.mono.edges { src := &check.mono.vertices[edge.src] dst := &check.mono.vertices[edge.dst] // N.B., we're looking for the greatest weight paths, unlike // typical Bellman-Ford. w := src.weight + edge.weight if w <= dst.weight { continue } dst.pre = i dst.len = src.len + 1 if dst.len == len(check.mono.vertices) { check.reportInstanceLoop(edge.dst) return } dst.weight = w again = true } } } func (check *Checker) reportInstanceLoop(v int) { var stack []int seen := make([]bool, len(check.mono.vertices)) // We have a path that contains a cycle and ends at v, but v may // only be reachable from the cycle, not on the cycle itself. We // start by walking backwards along the path until we find a vertex // that appears twice. for !seen[v] { stack = append(stack, v) seen[v] = true v = check.mono.edges[check.mono.vertices[v].pre].src } // Trim any vertices we visited before visiting v the first // time. Since v is the first vertex we found within the cycle, any // vertices we visited earlier cannot be part of the cycle. for stack[0] != v { stack = stack[1:] } // TODO(mdempsky): Pivot stack so we report the cycle from the top? var err error_ err.code = InvalidInstanceCycle obj0 := check.mono.vertices[v].obj err.errorf(obj0, "instantiation cycle:") qf := RelativeTo(check.pkg) for _, v := range stack { edge := check.mono.edges[check.mono.vertices[v].pre] obj := check.mono.vertices[edge.dst].obj switch obj.Type().(type) { default: panic("unexpected type") case *Named: err.errorf(edge.pos, "%s implicitly parameterized by %s", obj.Name(), TypeString(edge.typ, qf)) // secondary error, \t indented case *TypeParam: err.errorf(edge.pos, "%s instantiated as %s", obj.Name(), TypeString(edge.typ, qf)) // secondary error, \t indented } } check.report(&err) } // recordCanon records that tpar is the canonical type parameter // corresponding to method type parameter mpar. func (w *monoGraph) recordCanon(mpar, tpar *TypeParam) { if w.canon == nil { w.canon = make(map[*TypeParam]*TypeParam) } w.canon[mpar] = tpar } // recordInstance records that the given type parameters were // instantiated with the corresponding type arguments. func (w *monoGraph) recordInstance(pkg *Package, pos syntax.Pos, tparams []*TypeParam, targs []Type, xlist []syntax.Expr) { for i, tpar := range tparams { pos := pos if i < len(xlist) { pos = syntax.StartPos(xlist[i]) } w.assign(pkg, pos, tpar, targs[i]) } } // assign records that tpar was instantiated as targ at pos. func (w *monoGraph) assign(pkg *Package, pos syntax.Pos, tpar *TypeParam, targ Type) { // Go generics do not have an analog to C++`s template-templates, // where a template parameter can itself be an instantiable // template. So any instantiation cycles must occur within a single // package. Accordingly, we can ignore instantiations of imported // type parameters. // // TODO(mdempsky): Push this check up into recordInstance? All type // parameters in a list will appear in the same package. if tpar.Obj().Pkg() != pkg { return } // flow adds an edge from vertex src representing that typ flows to tpar. flow := func(src int, typ Type) { weight := 1 if typ == targ { weight = 0 } w.addEdge(w.typeParamVertex(tpar), src, weight, pos, targ) } // Recursively walk the type argument to find any defined types or // type parameters. var do func(typ Type) do = func(typ Type) { switch typ := Unalias(typ).(type) { default: panic("unexpected type") case *TypeParam: assert(typ.Obj().Pkg() == pkg) flow(w.typeParamVertex(typ), typ) case *Named: if src := w.localNamedVertex(pkg, typ.Origin()); src >= 0 { flow(src, typ) } targs := typ.TypeArgs() for i := 0; i < targs.Len(); i++ { do(targs.At(i)) } case *Array: do(typ.Elem()) case *Basic: // ok case *Chan: do(typ.Elem()) case *Map: do(typ.Key()) do(typ.Elem()) case *Pointer: do(typ.Elem()) case *Slice: do(typ.Elem()) case *Interface: for i := 0; i < typ.NumMethods(); i++ { do(typ.Method(i).Type()) } case *Signature: tuple := func(tup *Tuple) { for i := 0; i < tup.Len(); i++ { do(tup.At(i).Type()) } } tuple(typ.Params()) tuple(typ.Results()) case *Struct: for i := 0; i < typ.NumFields(); i++ { do(typ.Field(i).Type()) } } } do(targ) } // localNamedVertex returns the index of the vertex representing // named, or -1 if named doesn't need representation. func (w *monoGraph) localNamedVertex(pkg *Package, named *Named) int { obj := named.Obj() if obj.Pkg() != pkg { return -1 // imported type } root := pkg.Scope() if obj.Parent() == root { return -1 // package scope, no ambient type parameters } if idx, ok := w.nameIdx[obj]; ok { return idx } idx := -1 // Walk the type definition's scope to find any ambient type // parameters that it's implicitly parameterized by. for scope := obj.Parent(); scope != root; scope = scope.Parent() { for _, elem := range scope.elems { if elem, ok := elem.(*TypeName); ok && !elem.IsAlias() && cmpPos(elem.Pos(), obj.Pos()) < 0 { if tpar, ok := elem.Type().(*TypeParam); ok { if idx < 0 { idx = len(w.vertices) w.vertices = append(w.vertices, monoVertex{obj: obj}) } w.addEdge(idx, w.typeParamVertex(tpar), 1, obj.Pos(), tpar) } } } } if w.nameIdx == nil { w.nameIdx = make(map[*TypeName]int) } w.nameIdx[obj] = idx return idx } // typeParamVertex returns the index of the vertex representing tpar. func (w *monoGraph) typeParamVertex(tpar *TypeParam) int { if x, ok := w.canon[tpar]; ok { tpar = x } obj := tpar.Obj() if idx, ok := w.nameIdx[obj]; ok { return idx } if w.nameIdx == nil { w.nameIdx = make(map[*TypeName]int) } idx := len(w.vertices) w.vertices = append(w.vertices, monoVertex{obj: obj}) w.nameIdx[obj] = idx return idx } func (w *monoGraph) addEdge(dst, src, weight int, pos syntax.Pos, typ Type) { // TODO(mdempsky): Deduplicate redundant edges? w.edges = append(w.edges, monoEdge{ dst: dst, src: src, weight: weight, pos: pos, typ: typ, }) } PK ! ����/ �/ instantiate.gonu �[��� // Copyright 2021 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. // This file implements instantiation of generic types // through substitution of type parameters by type arguments. package types2 import ( "cmd/compile/internal/syntax" "errors" "fmt" . "internal/types/errors" ) // Instantiate instantiates the type orig with the given type arguments targs. // orig must be a *Named or a *Signature type. If there is no error, the // resulting Type is an instantiated type of the same kind (either a *Named or // a *Signature). Methods attached to a *Named type are also instantiated, and // associated with a new *Func that has the same position as the original // method, but nil function scope. // // If ctxt is non-nil, it may be used to de-duplicate the instance against // previous instances with the same identity. As a special case, generic // *Signature origin types are only considered identical if they are pointer // equivalent, so that instantiating distinct (but possibly identical) // signatures will yield different instances. The use of a shared context does // not guarantee that identical instances are deduplicated in all cases. // // If validate is set, Instantiate verifies that the number of type arguments // and parameters match, and that the type arguments satisfy their // corresponding type constraints. If verification fails, the resulting error // may wrap an *ArgumentError indicating which type argument did not satisfy // its corresponding type parameter constraint, and why. // // If validate is not set, Instantiate does not verify the type argument count // or whether the type arguments satisfy their constraints. Instantiate is // guaranteed to not return an error, but may panic. Specifically, for // *Signature types, Instantiate will panic immediately if the type argument // count is incorrect; for *Named types, a panic may occur later inside the // *Named API. func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error) { if ctxt == nil { ctxt = NewContext() } if validate { var tparams []*TypeParam switch t := orig.(type) { case *Named: tparams = t.TypeParams().list() case *Signature: tparams = t.TypeParams().list() } if len(targs) != len(tparams) { return nil, fmt.Errorf("got %d type arguments but %s has %d type parameters", len(targs), orig, len(tparams)) } if i, err := (*Checker)(nil).verify(nopos, tparams, targs, ctxt); err != nil { return nil, &ArgumentError{i, err} } } inst := (*Checker)(nil).instance(nopos, orig, targs, nil, ctxt) return inst, nil } // instance instantiates the given original (generic) function or type with the // provided type arguments and returns the resulting instance. If an identical // instance exists already in the given contexts, it returns that instance, // otherwise it creates a new one. // // If expanding is non-nil, it is the Named instance type currently being // expanded. If ctxt is non-nil, it is the context associated with the current // type-checking pass or call to Instantiate. At least one of expanding or ctxt // must be non-nil. // // For Named types the resulting instance may be unexpanded. func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, expanding *Named, ctxt *Context) (res Type) { // The order of the contexts below matters: we always prefer instances in the // expanding instance context in order to preserve reference cycles. // // Invariant: if expanding != nil, the returned instance will be the instance // recorded in expanding.inst.ctxt. var ctxts []*Context if expanding != nil { ctxts = append(ctxts, expanding.inst.ctxt) } if ctxt != nil { ctxts = append(ctxts, ctxt) } assert(len(ctxts) > 0) // Compute all hashes; hashes may differ across contexts due to different // unique IDs for Named types within the hasher. hashes := make([]string, len(ctxts)) for i, ctxt := range ctxts { hashes[i] = ctxt.instanceHash(orig, targs) } // If local is non-nil, updateContexts return the type recorded in // local. updateContexts := func(res Type) Type { for i := len(ctxts) - 1; i >= 0; i-- { res = ctxts[i].update(hashes[i], orig, targs, res) } return res } // typ may already have been instantiated with identical type arguments. In // that case, re-use the existing instance. for i, ctxt := range ctxts { if inst := ctxt.lookup(hashes[i], orig, targs); inst != nil { return updateContexts(inst) } } switch orig := orig.(type) { case *Named: res = check.newNamedInstance(pos, orig, targs, expanding) // substituted lazily case *Signature: assert(expanding == nil) // function instances cannot be reached from Named types tparams := orig.TypeParams() // TODO(gri) investigate if this is needed (type argument and parameter count seem to be correct here) if !check.validateTArgLen(pos, orig.String(), tparams.Len(), len(targs)) { return Typ[Invalid] } if tparams.Len() == 0 { return orig // nothing to do (minor optimization) } sig := check.subst(pos, orig, makeSubstMap(tparams.list(), targs), nil, ctxt).(*Signature) // If the signature doesn't use its type parameters, subst // will not make a copy. In that case, make a copy now (so // we can set tparams to nil w/o causing side-effects). if sig == orig { copy := *sig sig = © } // After instantiating a generic signature, it is not generic // anymore; we need to set tparams to nil. sig.tparams = nil res = sig default: // only types and functions can be generic panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig)) } // Update all contexts; it's possible that we've lost a race. return updateContexts(res) } // validateTArgLen checks that the number of type arguments (got) matches the // number of type parameters (want); if they don't match an error is reported. // If validation fails and check is nil, validateTArgLen panics. func (check *Checker) validateTArgLen(pos syntax.Pos, name string, want, got int) bool { var qual string switch { case got < want: qual = "not enough" case got > want: qual = "too many" default: return true } msg := check.sprintf("%s type arguments for type %s: have %d, want %d", qual, name, got, want) if check != nil { check.error(atPos(pos), WrongTypeArgCount, msg) return false } panic(fmt.Sprintf("%v: %s", pos, msg)) } func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type, ctxt *Context) (int, error) { smap := makeSubstMap(tparams, targs) for i, tpar := range tparams { // Ensure that we have a (possibly implicit) interface as type bound (go.dev/issue/51048). tpar.iface() // The type parameter bound is parameterized with the same type parameters // as the instantiated type; before we can use it for bounds checking we // need to instantiate it with the type arguments with which we instantiated // the parameterized type. bound := check.subst(pos, tpar.bound, smap, nil, ctxt) var cause string if !check.implements(pos, targs[i], bound, true, &cause) { return i, errors.New(cause) } } return -1, nil } // implements checks if V implements T. The receiver may be nil if implements // is called through an exported API call such as AssignableTo. If constraint // is set, T is a type constraint. // // If the provided cause is non-nil, it may be set to an error string // explaining why V does not implement (or satisfy, for constraints) T. func (check *Checker) implements(pos syntax.Pos, V, T Type, constraint bool, cause *string) bool { Vu := under(V) Tu := under(T) if !isValid(Vu) || !isValid(Tu) { return true // avoid follow-on errors } if p, _ := Vu.(*Pointer); p != nil && !isValid(under(p.base)) { return true // avoid follow-on errors (see go.dev/issue/49541 for an example) } verb := "implement" if constraint { verb = "satisfy" } Ti, _ := Tu.(*Interface) if Ti == nil { if cause != nil { var detail string if isInterfacePtr(Tu) { detail = check.sprintf("type %s is pointer to interface, not interface", T) } else { detail = check.sprintf("%s is not an interface", T) } *cause = check.sprintf("%s does not %s %s (%s)", V, verb, T, detail) } return false } // Every type satisfies the empty interface. if Ti.Empty() { return true } // T is not the empty interface (i.e., the type set of T is restricted) // An interface V with an empty type set satisfies any interface. // (The empty set is a subset of any set.) Vi, _ := Vu.(*Interface) if Vi != nil && Vi.typeSet().IsEmpty() { return true } // type set of V is not empty // No type with non-empty type set satisfies the empty type set. if Ti.typeSet().IsEmpty() { if cause != nil { *cause = check.sprintf("cannot %s %s (empty type set)", verb, T) } return false } // V must implement T's methods, if any. if m, _ := check.missingMethod(V, T, true, Identical, cause); m != nil /* !Implements(V, T) */ { if cause != nil { *cause = check.sprintf("%s does not %s %s %s", V, verb, T, *cause) } return false } // Only check comparability if we don't have a more specific error. checkComparability := func() bool { if !Ti.IsComparable() { return true } // If T is comparable, V must be comparable. // If V is strictly comparable, we're done. if comparable(V, false /* strict comparability */, nil, nil) { return true } // For constraint satisfaction, use dynamic (spec) comparability // so that ordinary, non-type parameter interfaces implement comparable. if constraint && comparable(V, true /* spec comparability */, nil, nil) { // V is comparable if we are at Go 1.20 or higher. if check == nil || check.allowVersion(check.pkg, atPos(pos), go1_20) { // atPos needed so that go/types generate passes return true } if cause != nil { *cause = check.sprintf("%s to %s comparable requires go1.20 or later", V, verb) } return false } if cause != nil { *cause = check.sprintf("%s does not %s comparable", V, verb) } return false } // V must also be in the set of types of T, if any. // Constraints with empty type sets were already excluded above. if !Ti.typeSet().hasTerms() { return checkComparability() // nothing to do } // If V is itself an interface, each of its possible types must be in the set // of T types (i.e., the V type set must be a subset of the T type set). // Interfaces V with empty type sets were already excluded above. if Vi != nil { if !Vi.typeSet().subsetOf(Ti.typeSet()) { // TODO(gri) report which type is missing if cause != nil { *cause = check.sprintf("%s does not %s %s", V, verb, T) } return false } return checkComparability() } // Otherwise, V's type must be included in the iface type set. var alt Type if Ti.typeSet().is(func(t *term) bool { if !t.includes(V) { // If V ∉ t.typ but V ∈ ~t.typ then remember this type // so we can suggest it as an alternative in the error // message. if alt == nil && !t.tilde && Identical(t.typ, under(t.typ)) { tt := *t tt.tilde = true if tt.includes(V) { alt = t.typ } } return true } return false }) { if cause != nil { var detail string switch { case alt != nil: detail = check.sprintf("possibly missing ~ for %s in %s", alt, T) case mentions(Ti, V): detail = check.sprintf("%s mentions %s, but %s is not in the type set of %s", T, V, V, T) default: detail = check.sprintf("%s missing in %s", V, Ti.typeSet().terms) } *cause = check.sprintf("%s does not %s %s (%s)", V, verb, T, detail) } return false } return checkComparability() } // mentions reports whether type T "mentions" typ in an (embedded) element or term // of T (whether typ is in the type set of T or not). For better error messages. func mentions(T, typ Type) bool { switch T := T.(type) { case *Interface: for _, e := range T.embeddeds { if mentions(e, typ) { return true } } case *Union: for _, t := range T.terms { if mentions(t.typ, typ) { return true } } default: if Identical(T, typ) { return true } } return false } PK ! �V� 2 2 compilersupport.gonu �[��� // Copyright 2021 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. // Helper functions exported for the compiler. // Do not use internally. package types2 // If t is a pointer, AsPointer returns that type, otherwise it returns nil. func AsPointer(t Type) *Pointer { u, _ := t.Underlying().(*Pointer) return u } // If t is a signature, AsSignature returns that type, otherwise it returns nil. func AsSignature(t Type) *Signature { u, _ := t.Underlying().(*Signature) return u } // If typ is a type parameter, CoreType returns the single underlying // type of all types in the corresponding type constraint if it exists, or // nil otherwise. If the type set contains only unrestricted and restricted // channel types (with identical element types), the single underlying type // is the restricted channel type if the restrictions are always the same. // If typ is not a type parameter, CoreType returns the underlying type. func CoreType(t Type) Type { return coreType(t) } PK ! �x� gccgosizes.gonu �[��� // Copyright 2019 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. // This is a copy of the file generated during the gccgo build process. // Last update 2019-01-22. package types2 var gccgoArchSizes = map[string]*StdSizes{ "386": {4, 4}, "alpha": {8, 8}, "amd64": {8, 8}, "amd64p32": {4, 8}, "arm": {4, 8}, "armbe": {4, 8}, "arm64": {8, 8}, "arm64be": {8, 8}, "ia64": {8, 8}, "loong64": {8, 8}, "m68k": {4, 2}, "mips": {4, 8}, "mipsle": {4, 8}, "mips64": {8, 8}, "mips64le": {8, 8}, "mips64p32": {4, 8}, "mips64p32le": {4, 8}, "nios2": {4, 8}, "ppc": {4, 8}, "ppc64": {8, 8}, "ppc64le": {8, 8}, "riscv": {4, 8}, "riscv64": {8, 8}, "s390": {4, 8}, "s390x": {8, 8}, "sh": {4, 8}, "shbe": {4, 8}, "sparc": {4, 8}, "sparc64": {8, 8}, "wasm": {8, 8}, } PK ! ��X/ X/ typestring.gonu �[��� // Copyright 2013 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. // This file implements printing of types. package types2 import ( "bytes" "fmt" "sort" "strconv" "strings" "unicode/utf8" ) // A Qualifier controls how named package-level objects are printed in // calls to TypeString, ObjectString, and SelectionString. // // These three formatting routines call the Qualifier for each // package-level object O, and if the Qualifier returns a non-empty // string p, the object is printed in the form p.O. // If it returns an empty string, only the object name O is printed. // // Using a nil Qualifier is equivalent to using (*Package).Path: the // object is qualified by the import path, e.g., "encoding/json.Marshal". type Qualifier func(*Package) string // RelativeTo returns a Qualifier that fully qualifies members of // all packages other than pkg. func RelativeTo(pkg *Package) Qualifier { if pkg == nil { return nil } return func(other *Package) string { if pkg == other { return "" // same package; unqualified } return other.Path() } } // TypeString returns the string representation of typ. // The Qualifier controls the printing of // package-level objects, and may be nil. func TypeString(typ Type, qf Qualifier) string { var buf bytes.Buffer WriteType(&buf, typ, qf) return buf.String() } // WriteType writes the string representation of typ to buf. // The Qualifier controls the printing of // package-level objects, and may be nil. func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier) { newTypeWriter(buf, qf).typ(typ) } // WriteSignature writes the representation of the signature sig to buf, // without a leading "func" keyword. The Qualifier controls the printing // of package-level objects, and may be nil. func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) { newTypeWriter(buf, qf).signature(sig) } type typeWriter struct { buf *bytes.Buffer seen map[Type]bool qf Qualifier ctxt *Context // if non-nil, we are type hashing tparams *TypeParamList // local type parameters paramNames bool // if set, write function parameter names, otherwise, write types only tpSubscripts bool // if set, write type parameter indices as subscripts pkgInfo bool // package-annotate first unexported-type field to avoid confusing type description } func newTypeWriter(buf *bytes.Buffer, qf Qualifier) *typeWriter { return &typeWriter{buf, make(map[Type]bool), qf, nil, nil, true, false, false} } func newTypeHasher(buf *bytes.Buffer, ctxt *Context) *typeWriter { assert(ctxt != nil) return &typeWriter{buf, make(map[Type]bool), nil, ctxt, nil, false, false, false} } func (w *typeWriter) byte(b byte) { if w.ctxt != nil { if b == ' ' { b = '#' } w.buf.WriteByte(b) return } w.buf.WriteByte(b) if b == ',' || b == ';' { w.buf.WriteByte(' ') } } func (w *typeWriter) string(s string) { w.buf.WriteString(s) } func (w *typeWriter) error(msg string) { if w.ctxt != nil { panic(msg) } w.buf.WriteString("<" + msg + ">") } func (w *typeWriter) typ(typ Type) { if w.seen[typ] { w.error("cycle to " + goTypeName(typ)) return } w.seen[typ] = true defer delete(w.seen, typ) switch t := typ.(type) { case nil: w.error("nil") case *Basic: // exported basic types go into package unsafe // (currently this is just unsafe.Pointer) if isExported(t.name) { if obj, _ := Unsafe.scope.Lookup(t.name).(*TypeName); obj != nil { w.typeName(obj) break } } w.string(t.name) case *Array: w.byte('[') w.string(strconv.FormatInt(t.len, 10)) w.byte(']') w.typ(t.elem) case *Slice: w.string("[]") w.typ(t.elem) case *Struct: w.string("struct{") for i, f := range t.fields { if i > 0 { w.byte(';') } // If disambiguating one struct for another, look for the first unexported field. // Do this first in case of nested structs; tag the first-outermost field. pkgAnnotate := false if w.qf == nil && w.pkgInfo && !isExported(f.name) { // note for embedded types, type name is field name, and "string" etc are lower case hence unexported. pkgAnnotate = true w.pkgInfo = false // only tag once } // This doesn't do the right thing for embedded type // aliases where we should print the alias name, not // the aliased type (see go.dev/issue/44410). if !f.embedded { w.string(f.name) w.byte(' ') } w.typ(f.typ) if pkgAnnotate { w.string(" /* package ") w.string(f.pkg.Path()) w.string(" */ ") } if tag := t.Tag(i); tag != "" { w.byte(' ') // TODO(gri) If tag contains blanks, replacing them with '#' // in Context.TypeHash may produce another tag // accidentally. w.string(strconv.Quote(tag)) } } w.byte('}') case *Pointer: w.byte('*') w.typ(t.base) case *Tuple: w.tuple(t, false) case *Signature: w.string("func") w.signature(t) case *Union: // Unions only appear as (syntactic) embedded elements // in interfaces and syntactically cannot be empty. if t.Len() == 0 { w.error("empty union") break } for i, t := range t.terms { if i > 0 { w.string(termSep) } if t.tilde { w.byte('~') } w.typ(t.typ) } case *Interface: if w.ctxt == nil { if t == universeAny.Type() { // When not hashing, we can try to improve type strings by writing "any" // for a type that is pointer-identical to universeAny. This logic should // be deprecated by more robust handling for aliases. w.string("any") break } if t == asNamed(universeComparable.Type()).underlying { w.string("interface{comparable}") break } } if t.implicit { if len(t.methods) == 0 && len(t.embeddeds) == 1 { w.typ(t.embeddeds[0]) break } // Something's wrong with the implicit interface. // Print it as such and continue. w.string("/* implicit */ ") } w.string("interface{") first := true if w.ctxt != nil { w.typeSet(t.typeSet()) } else { for _, m := range t.methods { if !first { w.byte(';') } first = false w.string(m.name) w.signature(m.typ.(*Signature)) } for _, typ := range t.embeddeds { if !first { w.byte(';') } first = false w.typ(typ) } } w.byte('}') case *Map: w.string("map[") w.typ(t.key) w.byte(']') w.typ(t.elem) case *Chan: var s string var parens bool switch t.dir { case SendRecv: s = "chan " // chan (<-chan T) requires parentheses if c, _ := t.elem.(*Chan); c != nil && c.dir == RecvOnly { parens = true } case SendOnly: s = "chan<- " case RecvOnly: s = "<-chan " default: w.error("unknown channel direction") } w.string(s) if parens { w.byte('(') } w.typ(t.elem) if parens { w.byte(')') } case *Named: // If hashing, write a unique prefix for t to represent its identity, since // named type identity is pointer identity. if w.ctxt != nil { w.string(strconv.Itoa(w.ctxt.getID(t))) } w.typeName(t.obj) // when hashing written for readability of the hash only if t.inst != nil { // instantiated type w.typeList(t.inst.targs.list()) } else if w.ctxt == nil && t.TypeParams().Len() != 0 { // For type hashing, don't need to format the TypeParams // parameterized type w.tParamList(t.TypeParams().list()) } case *TypeParam: if t.obj == nil { w.error("unnamed type parameter") break } if i := tparamIndex(w.tparams.list(), t); i >= 0 { // The names of type parameters that are declared by the type being // hashed are not part of the type identity. Replace them with a // placeholder indicating their index. w.string(fmt.Sprintf("$%d", i)) } else { w.string(t.obj.name) if w.tpSubscripts || w.ctxt != nil { w.string(subscript(t.id)) } // If the type parameter name is the same as a predeclared object // (say int), point out where it is declared to avoid confusing // error messages. This doesn't need to be super-elegant; we just // need a clear indication that this is not a predeclared name. if w.ctxt == nil && Universe.Lookup(t.obj.name) != nil { w.string(fmt.Sprintf(" /* with %s declared at %s */", t.obj.name, t.obj.Pos())) } } case *Alias: w.typeName(t.obj) if w.ctxt != nil { // TODO(gri) do we need to print the alias type name, too? w.typ(Unalias(t.obj.typ)) } default: // For externally defined implementations of Type. // Note: In this case cycles won't be caught. w.string(t.String()) } } // typeSet writes a canonical hash for an interface type set. func (w *typeWriter) typeSet(s *_TypeSet) { assert(w.ctxt != nil) first := true for _, m := range s.methods { if !first { w.byte(';') } first = false w.string(m.name) w.signature(m.typ.(*Signature)) } switch { case s.terms.isAll(): // nothing to do case s.terms.isEmpty(): w.string(s.terms.String()) default: var termHashes []string for _, term := range s.terms { // terms are not canonically sorted, so we sort their hashes instead. var buf bytes.Buffer if term.tilde { buf.WriteByte('~') } newTypeHasher(&buf, w.ctxt).typ(term.typ) termHashes = append(termHashes, buf.String()) } sort.Strings(termHashes) if !first { w.byte(';') } w.string(strings.Join(termHashes, "|")) } } func (w *typeWriter) typeList(list []Type) { w.byte('[') for i, typ := range list { if i > 0 { w.byte(',') } w.typ(typ) } w.byte(']') } func (w *typeWriter) tParamList(list []*TypeParam) { w.byte('[') var prev Type for i, tpar := range list { // Determine the type parameter and its constraint. // list is expected to hold type parameter names, // but don't crash if that's not the case. if tpar == nil { w.error("nil type parameter") continue } if i > 0 { if tpar.bound != prev { // bound changed - write previous one before advancing w.byte(' ') w.typ(prev) } w.byte(',') } prev = tpar.bound w.typ(tpar) } if prev != nil { w.byte(' ') w.typ(prev) } w.byte(']') } func (w *typeWriter) typeName(obj *TypeName) { w.string(packagePrefix(obj.pkg, w.qf)) w.string(obj.name) } func (w *typeWriter) tuple(tup *Tuple, variadic bool) { w.byte('(') if tup != nil { for i, v := range tup.vars { if i > 0 { w.byte(',') } // parameter names are ignored for type identity and thus type hashes if w.ctxt == nil && v.name != "" && w.paramNames { w.string(v.name) w.byte(' ') } typ := v.typ if variadic && i == len(tup.vars)-1 { if s, ok := typ.(*Slice); ok { w.string("...") typ = s.elem } else { // special case: // append(s, "foo"...) leads to signature func([]byte, string...) if t, _ := under(typ).(*Basic); t == nil || t.kind != String { w.error("expected string type") continue } w.typ(typ) w.string("...") continue } } w.typ(typ) } } w.byte(')') } func (w *typeWriter) signature(sig *Signature) { if sig.TypeParams().Len() != 0 { if w.ctxt != nil { assert(w.tparams == nil) w.tparams = sig.TypeParams() defer func() { w.tparams = nil }() } w.tParamList(sig.TypeParams().list()) } w.tuple(sig.params, sig.variadic) n := sig.results.Len() if n == 0 { // no result return } w.byte(' ') if n == 1 && (w.ctxt != nil || sig.results.vars[0].name == "") { // single unnamed result (if type hashing, name must be ignored) w.typ(sig.results.vars[0].typ) return } // multiple or named result(s) w.tuple(sig.results, false) } // subscript returns the decimal (utf8) representation of x using subscript digits. func subscript(x uint64) string { const w = len("₀") // all digits 0...9 have the same utf8 width var buf [32 * w]byte i := len(buf) for { i -= w utf8.EncodeRune(buf[i:], '₀'+rune(x%10)) // '₀' == U+2080 x /= 10 if x == 0 { break } } return string(buf[i:]) } PK ! �Z� testdata/manual.gonu �[��� // Copyright 2023 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. // This file is tested when running "go test -run Manual" // without source arguments. Use for one-off debugging. package p PK ! �\ìC C testdata/local/issue47996.gonu �[��� // Copyright 2021 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 p // don't crash func T /* ERROR "missing" */ [P] /* ERROR "missing" */ m /* ERROR "unexpected" */ () /* ERROR ")" */ { /* ERROR "{" */ } /* ERROR "}" */ PK ! 2��$A A slice.gonu �[��� // Copyright 2011 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 types2 // A Slice represents a slice type. type Slice struct { elem Type } // NewSlice returns a new slice type for the given element type. func NewSlice(elem Type) *Slice { return &Slice{elem: elem} } // Elem returns the element type of slice s. func (s *Slice) Elem() Type { return s.elem } func (s *Slice) Underlying() Type { return s } func (s *Slice) String() string { return TypeString(s, nil) } PK ! �� � errorcalls_test.gonu �[��� // Copyright 2021 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 types2_test import ( "cmd/compile/internal/syntax" "strconv" "testing" ) const ( errorfMinArgCount = 4 errorfFormatIndex = 2 ) // TestErrorCalls makes sure that check.errorf calls have at least // errorfMinArgCount arguments (otherwise we should use check.error) // and use balanced parentheses/brackets. func TestErrorCalls(t *testing.T) { files, err := pkgFiles(".") if err != nil { t.Fatal(err) } for _, file := range files { syntax.Inspect(file, func(n syntax.Node) bool { call, _ := n.(*syntax.CallExpr) if call == nil { return true } selx, _ := call.Fun.(*syntax.SelectorExpr) if selx == nil { return true } if !(isName(selx.X, "check") && isName(selx.Sel, "errorf")) { return true } // check.errorf calls should have at least errorfMinArgCount arguments: // position, code, format string, and arguments to format if n := len(call.ArgList); n < errorfMinArgCount { t.Errorf("%s: got %d arguments, want at least %d", call.Pos(), n, errorfMinArgCount) return false } format := call.ArgList[errorfFormatIndex] syntax.Inspect(format, func(n syntax.Node) bool { if lit, _ := n.(*syntax.BasicLit); lit != nil && lit.Kind == syntax.StringLit { if s, err := strconv.Unquote(lit.Value); err == nil { if !balancedParentheses(s) { t.Errorf("%s: unbalanced parentheses/brackets", lit.Pos()) } } return false } return true }) return false }) } } func isName(n syntax.Node, name string) bool { if n, ok := n.(*syntax.Name); ok { return n.Value == name } return false } func balancedParentheses(s string) bool { var stack []byte for _, ch := range s { var open byte switch ch { case '(', '[', '{': stack = append(stack, byte(ch)) continue case ')': open = '(' case ']': open = '[' case '}': open = '{' default: continue } // closing parenthesis/bracket must have matching opening top := len(stack) - 1 if top < 0 || stack[top] != open { return false } stack = stack[:top] } return len(stack) == 0 } PK ! zd�� � gcsizes.gonu �[��� // Copyright 2023 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 types2 type gcSizes struct { WordSize int64 // word size in bytes - must be >= 4 (32bits) MaxAlign int64 // maximum alignment in bytes - must be >= 1 } func (s *gcSizes) Alignof(T Type) (result int64) { defer func() { assert(result >= 1) }() // For arrays and structs, alignment is defined in terms // of alignment of the elements and fields, respectively. switch t := under(T).(type) { case *Array: // spec: "For a variable x of array type: unsafe.Alignof(x) // is the same as unsafe.Alignof(x[0]), but at least 1." return s.Alignof(t.elem) case *Struct: if len(t.fields) == 0 && IsSyncAtomicAlign64(T) { // Special case: sync/atomic.align64 is an // empty struct we recognize as a signal that // the struct it contains must be // 64-bit-aligned. // // This logic is equivalent to the logic in // cmd/compile/internal/types/size.go:calcStructOffset return 8 } // spec: "For a variable x of struct type: unsafe.Alignof(x) // is the largest of the values unsafe.Alignof(x.f) for each // field f of x, but at least 1." max := int64(1) for _, f := range t.fields { if a := s.Alignof(f.typ); a > max { max = a } } return max case *Slice, *Interface: // Multiword data structures are effectively structs // in which each element has size WordSize. // Type parameters lead to variable sizes/alignments; // StdSizes.Alignof won't be called for them. assert(!isTypeParam(T)) return s.WordSize case *Basic: // Strings are like slices and interfaces. if t.Info()&IsString != 0 { return s.WordSize } case *TypeParam, *Union: unreachable() } a := s.Sizeof(T) // may be 0 or negative // spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1." if a < 1 { return 1 } // complex{64,128} are aligned like [2]float{32,64}. if isComplex(T) { a /= 2 } if a > s.MaxAlign { return s.MaxAlign } return a } func (s *gcSizes) Offsetsof(fields []*Var) []int64 { offsets := make([]int64, len(fields)) var offs int64 for i, f := range fields { if offs < 0 { // all remaining offsets are too large offsets[i] = -1 continue } // offs >= 0 a := s.Alignof(f.typ) offs = align(offs, a) // possibly < 0 if align overflows offsets[i] = offs if d := s.Sizeof(f.typ); d >= 0 && offs >= 0 { offs += d // ok to overflow to < 0 } else { offs = -1 // f.typ or offs is too large } } return offsets } func (s *gcSizes) Sizeof(T Type) int64 { switch t := under(T).(type) { case *Basic: assert(isTyped(T)) k := t.kind if int(k) < len(basicSizes) { if s := basicSizes[k]; s > 0 { return int64(s) } } if k == String { return s.WordSize * 2 } case *Array: n := t.len if n <= 0 { return 0 } // n > 0 esize := s.Sizeof(t.elem) if esize < 0 { return -1 // element too large } if esize == 0 { return 0 // 0-size element } // esize > 0 // Final size is esize * n; and size must be <= maxInt64. const maxInt64 = 1<<63 - 1 if esize > maxInt64/n { return -1 // esize * n overflows } return esize * n case *Slice: return s.WordSize * 3 case *Struct: n := t.NumFields() if n == 0 { return 0 } offsets := s.Offsetsof(t.fields) offs := offsets[n-1] size := s.Sizeof(t.fields[n-1].typ) if offs < 0 || size < 0 { return -1 // type too large } // gc: The last field of a non-zero-sized struct is not allowed to // have size 0. if offs > 0 && size == 0 { size = 1 } // gc: Size includes alignment padding. return align(offs+size, s.Alignof(t)) // may overflow to < 0 which is ok case *Interface: // Type parameters lead to variable sizes/alignments; // StdSizes.Sizeof won't be called for them. assert(!isTypeParam(T)) return s.WordSize * 2 case *TypeParam, *Union: unreachable() } return s.WordSize // catch-all } // gcSizesFor returns the Sizes used by gc for an architecture. // The result is a nil *gcSizes pointer (which is not a valid types.Sizes) // if a compiler/architecture pair is not known. func gcSizesFor(compiler, arch string) *gcSizes { if compiler != "gc" { return nil } return gcArchSizes[arch] } PK ! /�>v� � api_predicates.gonu �[��� // Copyright 2023 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. // This file implements exported type predicates. package types2 // AssertableTo reports whether a value of type V can be asserted to have type T. // // The behavior of AssertableTo is unspecified in three cases: // - if T is Typ[Invalid] // - if V is a generalized interface; i.e., an interface that may only be used // as a type constraint in Go code // - if T is an uninstantiated generic type func AssertableTo(V *Interface, T Type) bool { // Checker.newAssertableTo suppresses errors for invalid types, so we need special // handling here. if !isValid(T.Underlying()) { return false } return (*Checker)(nil).newAssertableTo(nopos, V, T, nil) } // AssignableTo reports whether a value of type V is assignable to a variable // of type T. // // The behavior of AssignableTo is unspecified if V or T is Typ[Invalid] or an // uninstantiated generic type. func AssignableTo(V, T Type) bool { x := operand{mode: value, typ: V} ok, _ := x.assignableTo(nil, T, nil) // check not needed for non-constant x return ok } // ConvertibleTo reports whether a value of type V is convertible to a value of // type T. // // The behavior of ConvertibleTo is unspecified if V or T is Typ[Invalid] or an // uninstantiated generic type. func ConvertibleTo(V, T Type) bool { x := operand{mode: value, typ: V} return x.convertibleTo(nil, T, nil) // check not needed for non-constant x } // Implements reports whether type V implements interface T. // // The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated // generic type. func Implements(V Type, T *Interface) bool { if T.Empty() { // All types (even Typ[Invalid]) implement the empty interface. return true } // Checker.implements suppresses errors for invalid types, so we need special // handling here. if !isValid(V.Underlying()) { return false } return (*Checker)(nil).implements(nopos, V, T, false, nil) } // Satisfies reports whether type V satisfies the constraint T. // // The behavior of Satisfies is unspecified if V is Typ[Invalid] or an uninstantiated // generic type. func Satisfies(V Type, T *Interface) bool { return (*Checker)(nil).implements(nopos, V, T, true, nil) } // Identical reports whether x and y are identical types. // Receivers of [Signature] types are ignored. func Identical(x, y Type) bool { var c comparer return c.identical(x, y, nil) } // IdenticalIgnoreTags reports whether x and y are identical types if tags are ignored. // Receivers of [Signature] types are ignored. func IdenticalIgnoreTags(x, y Type) bool { var c comparer c.ignoreTags = true return c.identical(x, y, nil) } PK ! ;��4 4 context_test.gonu �[��� // Copyright 2021 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 types2 import ( "testing" ) func TestContextHashCollisions(t *testing.T) { if debug { t.Skip("hash collisions are expected, and would fail debug assertions") } // Unit test the de-duplication fall-back logic in Context. // // We can't test this via Instantiate because this is only a fall-back in // case our hash is imperfect. // // These lookups and updates use reasonable looking types in an attempt to // make them robust to internal type assertions, but could equally well use // arbitrary types. // Create some distinct origin types. nullaryP and nullaryQ have no // parameters and are identical (but have different type parameter names). // unaryP has a parameter. var nullaryP, nullaryQ, unaryP Type { // type nullaryP = func[P any]() tparam := NewTypeParam(NewTypeName(nopos, nil, "P", nil), &emptyInterface) nullaryP = NewSignatureType(nil, nil, []*TypeParam{tparam}, nil, nil, false) } { // type nullaryQ = func[Q any]() tparam := NewTypeParam(NewTypeName(nopos, nil, "Q", nil), &emptyInterface) nullaryQ = NewSignatureType(nil, nil, []*TypeParam{tparam}, nil, nil, false) } { // type unaryP = func[P any](_ P) tparam := NewTypeParam(NewTypeName(nopos, nil, "P", nil), &emptyInterface) params := NewTuple(NewVar(nopos, nil, "_", tparam)) unaryP = NewSignatureType(nil, nil, []*TypeParam{tparam}, params, nil, false) } ctxt := NewContext() // Update the context with an instantiation of nullaryP. inst := NewSignatureType(nil, nil, nil, nil, nil, false) if got := ctxt.update("", nullaryP, []Type{Typ[Int]}, inst); got != inst { t.Error("bad") } // unaryP is not identical to nullaryP, so we should not get inst when // instantiated with identical type arguments. if got := ctxt.lookup("", unaryP, []Type{Typ[Int]}); got != nil { t.Error("bad") } // nullaryQ is identical to nullaryP, so we *should* get inst when // instantiated with identical type arguments. if got := ctxt.lookup("", nullaryQ, []Type{Typ[Int]}); got != inst { t.Error("bad") } // ...but verify we don't get inst with different type arguments. if got := ctxt.lookup("", nullaryQ, []Type{Typ[String]}); got != nil { t.Error("bad") } } PK ! dv���4 �4 stdlib_test.gonu �[��� // Copyright 2013 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. // This file tests types2.Check by using it to // typecheck the standard library and tests. package types2_test import ( "bytes" "cmd/compile/internal/syntax" "errors" "fmt" "go/build" "internal/testenv" "os" "path/filepath" "runtime" "strings" "sync" "testing" "time" . "cmd/compile/internal/types2" ) var stdLibImporter = defaultImporter() func TestStdlib(t *testing.T) { if testing.Short() { t.Skip("skipping in short mode") } testenv.MustHaveGoBuild(t) // Collect non-test files. dirFiles := make(map[string][]string) root := filepath.Join(testenv.GOROOT(t), "src") walkPkgDirs(root, func(dir string, filenames []string) { dirFiles[dir] = filenames }, t.Error) c := &stdlibChecker{ dirFiles: dirFiles, pkgs: make(map[string]*futurePackage), } start := time.Now() // Though we read files while parsing, type-checking is otherwise CPU bound. // // This doesn't achieve great CPU utilization as many packages may block // waiting for a common import, but in combination with the non-deterministic // map iteration below this should provide decent coverage of concurrent // type-checking (see golang/go#47729). cpulimit := make(chan struct{}, runtime.GOMAXPROCS(0)) var wg sync.WaitGroup for dir := range dirFiles { dir := dir cpulimit <- struct{}{} wg.Add(1) go func() { defer func() { wg.Done() <-cpulimit }() _, err := c.getDirPackage(dir) if err != nil { t.Errorf("error checking %s: %v", dir, err) } }() } wg.Wait() if testing.Verbose() { fmt.Println(len(dirFiles), "packages typechecked in", time.Since(start)) } } // stdlibChecker implements concurrent type-checking of the packages defined by // dirFiles, which must define a closed set of packages (such as GOROOT/src). type stdlibChecker struct { dirFiles map[string][]string // non-test files per directory; must be pre-populated mu sync.Mutex pkgs map[string]*futurePackage // future cache of type-checking results } // A futurePackage is a future result of type-checking. type futurePackage struct { done chan struct{} // guards pkg and err pkg *Package err error } func (c *stdlibChecker) Import(path string) (*Package, error) { panic("unimplemented: use ImportFrom") } func (c *stdlibChecker) ImportFrom(path, dir string, _ ImportMode) (*Package, error) { if path == "unsafe" { // unsafe cannot be type checked normally. return Unsafe, nil } p, err := build.Default.Import(path, dir, build.FindOnly) if err != nil { return nil, err } pkg, err := c.getDirPackage(p.Dir) if pkg != nil { // As long as pkg is non-nil, avoid redundant errors related to failed // imports. TestStdlib will collect errors once for each package. return pkg, nil } return nil, err } // getDirPackage gets the package defined in dir from the future cache. // // If this is the first goroutine requesting the package, getDirPackage // type-checks. func (c *stdlibChecker) getDirPackage(dir string) (*Package, error) { c.mu.Lock() fut, ok := c.pkgs[dir] if !ok { // First request for this package dir; type check. fut = &futurePackage{ done: make(chan struct{}), } c.pkgs[dir] = fut files, ok := c.dirFiles[dir] c.mu.Unlock() if !ok { fut.err = fmt.Errorf("no files for %s", dir) } else { // Using dir as the package path here may be inconsistent with the behavior // of a normal importer, but is sufficient as dir is by construction unique // to this package. fut.pkg, fut.err = typecheckFiles(dir, files, c) } close(fut.done) } else { // Otherwise, await the result. c.mu.Unlock() <-fut.done } return fut.pkg, fut.err } // firstComment returns the contents of the first non-empty comment in // the given file, "skip", or the empty string. No matter the present // comments, if any of them contains a build tag, the result is always // "skip". Only comments within the first 4K of the file are considered. // TODO(gri) should only read until we see "package" token. func firstComment(filename string) (first string) { f, err := os.Open(filename) if err != nil { return "" } defer f.Close() // read at most 4KB var buf [4 << 10]byte n, _ := f.Read(buf[:]) src := bytes.NewBuffer(buf[:n]) // TODO(gri) we need a better way to terminate CommentsDo defer func() { if p := recover(); p != nil { if s, ok := p.(string); ok { first = s } } }() syntax.CommentsDo(src, func(_, _ uint, text string) { if text[0] != '/' { return // not a comment } // extract comment text if text[1] == '*' { text = text[:len(text)-2] } text = strings.TrimSpace(text[2:]) if strings.HasPrefix(text, "go:build ") { panic("skip") } if first == "" { first = text // text may be "" but that's ok } // continue as we may still see build tags }) return } func testTestDir(t *testing.T, path string, ignore ...string) { files, err := os.ReadDir(path) if err != nil { // cmd/distpack deletes GOROOT/test, so skip the test if it isn't present. // cmd/distpack also requires GOROOT/VERSION to exist, so use that to // suppress false-positive skips. if _, err := os.Stat(filepath.Join(testenv.GOROOT(t), "test")); os.IsNotExist(err) { if _, err := os.Stat(filepath.Join(testenv.GOROOT(t), "VERSION")); err == nil { t.Skipf("skipping: GOROOT/test not present") } } t.Fatal(err) } excluded := make(map[string]bool) for _, filename := range ignore { excluded[filename] = true } for _, f := range files { // filter directory contents if f.IsDir() || !strings.HasSuffix(f.Name(), ".go") || excluded[f.Name()] { continue } // get per-file instructions expectErrors := false filename := filepath.Join(path, f.Name()) goVersion := "" if comment := firstComment(filename); comment != "" { if strings.Contains(comment, "-goexperiment") { continue // ignore this file } fields := strings.Fields(comment) switch fields[0] { case "skip", "compiledir": continue // ignore this file case "errorcheck": expectErrors = true for _, arg := range fields[1:] { if arg == "-0" || arg == "-+" || arg == "-std" { // Marked explicitly as not expecting errors (-0), // or marked as compiling runtime/stdlib, which is only done // to trigger runtime/stdlib-only error output. // In both cases, the code should typecheck. expectErrors = false break } const prefix = "-lang=" if strings.HasPrefix(arg, prefix) { goVersion = arg[len(prefix):] } } } } // parse and type-check file if testing.Verbose() { fmt.Println("\t", filename) } file, err := syntax.ParseFile(filename, nil, nil, 0) if err == nil { conf := Config{ GoVersion: goVersion, Importer: stdLibImporter, } _, err = conf.Check(filename, []*syntax.File{file}, nil) } if expectErrors { if err == nil { t.Errorf("expected errors but found none in %s", filename) } } else { if err != nil { t.Error(err) } } } } func TestStdTest(t *testing.T) { testenv.MustHaveGoBuild(t) if testing.Short() && testenv.Builder() == "" { t.Skip("skipping in short mode") } testTestDir(t, filepath.Join(testenv.GOROOT(t), "test"), "cmplxdivide.go", // also needs file cmplxdivide1.go - ignore "directive.go", // tests compiler rejection of bad directive placement - ignore "directive2.go", // tests compiler rejection of bad directive placement - ignore "embedfunc.go", // tests //go:embed "embedvers.go", // tests //go:embed "linkname2.go", // types2 doesn't check validity of //go:xxx directives "linkname3.go", // types2 doesn't check validity of //go:xxx directives ) } func TestStdFixed(t *testing.T) { testenv.MustHaveGoBuild(t) if testing.Short() && testenv.Builder() == "" { t.Skip("skipping in short mode") } testTestDir(t, filepath.Join(testenv.GOROOT(t), "test", "fixedbugs"), "bug248.go", "bug302.go", "bug369.go", // complex test instructions - ignore "bug398.go", // types2 doesn't check for anonymous interface cycles (go.dev/issue/56103) "issue6889.go", // gc-specific test "issue11362.go", // canonical import path check "issue16369.go", // types2 handles this correctly - not an issue "issue18459.go", // types2 doesn't check validity of //go:xxx directives "issue18882.go", // types2 doesn't check validity of //go:xxx directives "issue20529.go", // types2 does not have constraints on stack size "issue22200.go", // types2 does not have constraints on stack size "issue22200b.go", // types2 does not have constraints on stack size "issue25507.go", // types2 does not have constraints on stack size "issue20780.go", // types2 does not have constraints on stack size "issue42058a.go", // types2 does not have constraints on channel element size "issue42058b.go", // types2 does not have constraints on channel element size "issue48097.go", // go/types doesn't check validity of //go:xxx directives, and non-init bodyless function "issue48230.go", // go/types doesn't check validity of //go:xxx directives "issue49767.go", // go/types does not have constraints on channel element size "issue49814.go", // go/types does not have constraints on array size "issue56103.go", // anonymous interface cycles; will be a type checker error in 1.22 "issue52697.go", // types2 does not have constraints on stack size // These tests requires runtime/cgo.Incomplete, which is only available on some platforms. // However, types2 does not know about build constraints. "bug514.go", "issue40954.go", "issue42032.go", "issue42076.go", "issue46903.go", "issue51733.go", "notinheap2.go", "notinheap3.go", ) } func TestStdKen(t *testing.T) { testenv.MustHaveGoBuild(t) testTestDir(t, filepath.Join(testenv.GOROOT(t), "test", "ken")) } // Package paths of excluded packages. var excluded = map[string]bool{ "builtin": true, // go.dev/issue/46027: some imports are missing for this submodule. "crypto/internal/edwards25519/field/_asm": true, "crypto/internal/bigmod/_asm": true, } // printPackageMu synchronizes the printing of type-checked package files in // the typecheckFiles function. // // Without synchronization, package files may be interleaved during concurrent // type-checking. var printPackageMu sync.Mutex // typecheckFiles typechecks the given package files. func typecheckFiles(path string, filenames []string, importer Importer) (*Package, error) { // Parse package files. var files []*syntax.File for _, filename := range filenames { var errs []error errh := func(err error) { errs = append(errs, err) } file, err := syntax.ParseFile(filename, errh, nil, 0) if err != nil { return nil, errors.Join(errs...) } files = append(files, file) } if testing.Verbose() { printPackageMu.Lock() fmt.Println("package", files[0].PkgName.Value) for _, filename := range filenames { fmt.Println("\t", filename) } printPackageMu.Unlock() } // Typecheck package files. var errs []error conf := Config{ Error: func(err error) { errs = append(errs, err) }, Importer: importer, } info := Info{Uses: make(map[*syntax.Name]Object)} pkg, _ := conf.Check(path, files, &info) err := errors.Join(errs...) if err != nil { return pkg, err } // Perform checks of API invariants. // All Objects have a package, except predeclared ones. errorError := Universe.Lookup("error").Type().Underlying().(*Interface).ExplicitMethod(0) // (error).Error for id, obj := range info.Uses { predeclared := obj == Universe.Lookup(obj.Name()) || obj == errorError if predeclared == (obj.Pkg() != nil) { posn := id.Pos() if predeclared { return nil, fmt.Errorf("%s: predeclared object with package: %s", posn, obj) } else { return nil, fmt.Errorf("%s: user-defined object without package: %s", posn, obj) } } } return pkg, nil } // pkgFilenames returns the list of package filenames for the given directory. func pkgFilenames(dir string, includeTest bool) ([]string, error) { ctxt := build.Default ctxt.CgoEnabled = false pkg, err := ctxt.ImportDir(dir, 0) if err != nil { if _, nogo := err.(*build.NoGoError); nogo { return nil, nil // no *.go files, not an error } return nil, err } if excluded[pkg.ImportPath] { return nil, nil } var filenames []string for _, name := range pkg.GoFiles { filenames = append(filenames, filepath.Join(pkg.Dir, name)) } if includeTest { for _, name := range pkg.TestGoFiles { filenames = append(filenames, filepath.Join(pkg.Dir, name)) } } return filenames, nil } func walkPkgDirs(dir string, pkgh func(dir string, filenames []string), errh func(args ...interface{})) { w := walker{pkgh, errh} w.walk(dir) } type walker struct { pkgh func(dir string, filenames []string) errh func(args ...any) } func (w *walker) walk(dir string) { files, err := os.ReadDir(dir) if err != nil { w.errh(err) return } // apply pkgh to the files in directory dir // Don't get test files as these packages are imported. pkgFiles, err := pkgFilenames(dir, false) if err != nil { w.errh(err) return } if pkgFiles != nil { w.pkgh(dir, pkgFiles) } // traverse subdirectories, but don't walk into testdata for _, f := range files { if f.IsDir() && f.Name() != "testdata" { w.walk(filepath.Join(dir, f.Name())) } } } PK ! do� � object_test.gonu �[��� // Copyright 2016 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 types2_test import ( "internal/testenv" "strings" "testing" . "cmd/compile/internal/types2" ) func TestIsAlias(t *testing.T) { check := func(obj *TypeName, want bool) { if got := obj.IsAlias(); got != want { t.Errorf("%v: got IsAlias = %v; want %v", obj, got, want) } } // predeclared types check(Unsafe.Scope().Lookup("Pointer").(*TypeName), false) for _, name := range Universe.Names() { if obj, _ := Universe.Lookup(name).(*TypeName); obj != nil { check(obj, name == "any" || name == "byte" || name == "rune") } } // various other types pkg := NewPackage("p", "p") t1 := NewTypeName(nopos, pkg, "t1", nil) n1 := NewNamed(t1, new(Struct), nil) t5 := NewTypeName(nopos, pkg, "t5", nil) NewTypeParam(t5, nil) for _, test := range []struct { name *TypeName alias bool }{ {NewTypeName(nopos, nil, "t0", nil), false}, // no type yet {NewTypeName(nopos, pkg, "t0", nil), false}, // no type yet {t1, false}, // type name refers to named type and vice versa {NewTypeName(nopos, nil, "t2", NewInterfaceType(nil, nil)), true}, // type name refers to unnamed type {NewTypeName(nopos, pkg, "t3", n1), true}, // type name refers to named type with different type name {NewTypeName(nopos, nil, "t4", Typ[Int32]), true}, // type name refers to basic type with different name {NewTypeName(nopos, nil, "int32", Typ[Int32]), false}, // type name refers to basic type with same name {NewTypeName(nopos, pkg, "int32", Typ[Int32]), true}, // type name is declared in user-defined package (outside Universe) {NewTypeName(nopos, nil, "rune", Typ[Rune]), true}, // type name refers to basic type rune which is an alias already {t5, false}, // type name refers to type parameter and vice versa } { check(test.name, test.alias) } } // TestEmbeddedMethod checks that an embedded method is represented by // the same Func Object as the original method. See also go.dev/issue/34421. func TestEmbeddedMethod(t *testing.T) { const src = `package p; type I interface { error }` pkg := mustTypecheck(src, nil, nil) // get original error.Error method eface := Universe.Lookup("error") orig, _, _ := LookupFieldOrMethod(eface.Type(), false, nil, "Error") if orig == nil { t.Fatalf("original error.Error not found") } // get embedded error.Error method iface := pkg.Scope().Lookup("I") embed, _, _ := LookupFieldOrMethod(iface.Type(), false, nil, "Error") if embed == nil { t.Fatalf("embedded error.Error not found") } // original and embedded Error object should be identical if orig != embed { t.Fatalf("%s (%p) != %s (%p)", orig, orig, embed, embed) } } var testObjects = []struct { src string obj string want string }{ {"import \"io\"; var r io.Reader", "r", "var p.r io.Reader"}, {"const c = 1.2", "c", "const p.c untyped float"}, {"const c float64 = 3.14", "c", "const p.c float64"}, {"type t struct{f int}", "t", "type p.t struct{f int}"}, {"type t func(int)", "t", "type p.t func(int)"}, {"type t[P any] struct{f P}", "t", "type p.t[P any] struct{f P}"}, {"type t[P any] struct{f P}", "t.P", "type parameter P any"}, {"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C"}, {"type t = struct{f int}", "t", "type p.t = struct{f int}"}, {"type t = func(int)", "t", "type p.t = func(int)"}, {"var v int", "v", "var p.v int"}, {"func f(int) string", "f", "func p.f(int) string"}, {"func g[P any](x P){}", "g", "func p.g[P any](x P)"}, {"func g[P interface{~int}](x P){}", "g.P", "type parameter P interface{~int}"}, {"", "any", "type any = interface{}"}, } func TestObjectString(t *testing.T) { testenv.MustHaveGoBuild(t) for _, test := range testObjects { src := "package p; " + test.src pkg, err := typecheck(src, nil, nil) if err != nil { t.Errorf("%s: %s", src, err) continue } names := strings.Split(test.obj, ".") if len(names) != 1 && len(names) != 2 { t.Errorf("%s: invalid object path %s", test.src, test.obj) continue } _, obj := pkg.Scope().LookupParent(names[0], nopos) if obj == nil { t.Errorf("%s: %s not found", test.src, names[0]) continue } if len(names) == 2 { if typ, ok := obj.Type().(interface{ TypeParams() *TypeParamList }); ok { obj = lookupTypeParamObj(typ.TypeParams(), names[1]) if obj == nil { t.Errorf("%s: %s not found", test.src, test.obj) continue } } else { t.Errorf("%s: %s has no type parameters", test.src, names[0]) continue } } if got := obj.String(); got != test.want { t.Errorf("%s: got %s, want %s", test.src, got, test.want) } } } func lookupTypeParamObj(list *TypeParamList, name string) Object { for i := 0; i < list.Len(); i++ { tpar := list.At(i) if tpar.Obj().Name() == name { return tpar.Obj() } } return nil } PK ! 8{�� � version.gonu �[��� // Copyright 2021 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 types2 import ( "cmd/compile/internal/syntax" "fmt" "go/version" "internal/goversion" "strings" ) // A goVersion is a Go language version string of the form "go1.%d" // where d is the minor version number. goVersion strings don't // contain release numbers ("go1.20.1" is not a valid goVersion). type goVersion string // asGoVersion returns v as a goVersion (e.g., "go1.20.1" becomes "go1.20"). // If v is not a valid Go version, the result is the empty string. func asGoVersion(v string) goVersion { return goVersion(version.Lang(v)) } // isValid reports whether v is a valid Go version. func (v goVersion) isValid() bool { return v != "" } // cmp returns -1, 0, or +1 depending on whether x < y, x == y, or x > y, // interpreted as Go versions. func (x goVersion) cmp(y goVersion) int { return version.Compare(string(x), string(y)) } var ( // Go versions that introduced language changes go1_9 = asGoVersion("go1.9") go1_13 = asGoVersion("go1.13") go1_14 = asGoVersion("go1.14") go1_17 = asGoVersion("go1.17") go1_18 = asGoVersion("go1.18") go1_20 = asGoVersion("go1.20") go1_21 = asGoVersion("go1.21") go1_22 = asGoVersion("go1.22") // current (deployed) Go version go_current = asGoVersion(fmt.Sprintf("go1.%d", goversion.Version)) ) // langCompat reports an error if the representation of a numeric // literal is not compatible with the current language version. func (check *Checker) langCompat(lit *syntax.BasicLit) { s := lit.Value if len(s) <= 2 || check.allowVersion(check.pkg, lit, go1_13) { return } // len(s) > 2 if strings.Contains(s, "_") { check.versionErrorf(lit, go1_13, "underscores in numeric literals") return } if s[0] != '0' { return } radix := s[1] if radix == 'b' || radix == 'B' { check.versionErrorf(lit, go1_13, "binary literals") return } if radix == 'o' || radix == 'O' { check.versionErrorf(lit, go1_13, "0o/0O-style octal literals") return } if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') { check.versionErrorf(lit, go1_13, "hexadecimal floating-point literals") } } // allowVersion reports whether the given package is allowed to use version v. func (check *Checker) allowVersion(pkg *Package, at poser, v goVersion) bool { // We assume that imported packages have all been checked, // so we only have to check for the local package. if pkg != check.pkg { return true } // If no explicit file version is specified, // fileVersion corresponds to the module version. var fileVersion goVersion if pos := at.Pos(); pos.IsKnown() { // We need version.Lang below because file versions // can be (unaltered) Config.GoVersion strings that // may contain dot-release information. fileVersion = asGoVersion(check.versions[base(pos)]) } return !fileVersion.isValid() || fileVersion.cmp(v) >= 0 } // verifyVersionf is like allowVersion but also accepts a format string and arguments // which are used to report a version error if allowVersion returns false. It uses the // current package. func (check *Checker) verifyVersionf(at poser, v goVersion, format string, args ...interface{}) bool { if !check.allowVersion(check.pkg, at, v) { check.versionErrorf(at, v, format, args...) return false } return true } // base finds the underlying PosBase of the source file containing pos, // skipping over intermediate PosBase layers created by //line directives. // The positions must be known. func base(pos syntax.Pos) *syntax.PosBase { assert(pos.IsKnown()) b := pos.Base() for { bb := b.Pos().Base() if bb == nil || bb == b { break } b = bb } return b } PK ! ���� � importer_test.gonu �[��� PK ! "�+T� � � expr.gonu �[��� PK ! &cˠ � � objset.gonu �[��� PK ! ���� � �� interface.gonu �[��� PK ! )��6# 6# � sizes.gonu �[��� PK ! ���_' _' ~ initorder.gonu �[��� PK ! �`� D D 7 api.gonu �[��� PK ! �ٕ� � `{ mono_test.gonu �[��� PK ! E��- �- p� index.gonu �[��� PK ! �� z� errors_test.gonu �[��� PK ! s֝� �� termlist.gonu �[��� PK ! ����% �% � scope.gonu �[��� PK ! ��Pv v �� example_test.gonu �[��� PK ! �g��# # � array.gonu �[��� PK ! P'� < < � type.gonu �[��� PK ! g(��� � P map.gonu �[��� PK ! �����6 �6 check_test.gonu �[��� PK ! G��.g5 g5 �G typeset.gonu �[��� PK ! o �� � �} under.gonu �[��� PK ! kM i i x� return.gonu �[��� PK ! �0�z �z � stmt.gonu �[��� PK ! �XG� � > typestring_test.gonu �[��� PK ! ](@�F F 2% instantiate_test.gonu �[��� PK ! }q�xP P �< main_test.gonu �[��� PK ! �=J G> const.gonu �[��� PK ! �M���h �h �\ infer.gonu �[��� PK ! �E˹Z �Z b� named.gonu �[��� PK ! �FB�U �U S check.gonu �[��� PK ! =*��@. @. tv subst.gonu �[��� PK ! ^<'�N �N � lookup.gonu �[��� PK ! �Y y �� labels.gonu �[��� PK ! v� �� � � package.gonu �[��� PK ! %P�,- - � alias.gonu �[��� PK ! �^8� @& union.gonu �[��� PK ! �e~�,p ,p z? issues_test.gonu �[��� PK ! �(� � sizeof_test.gonu �[��� PK ! �˹�� � <� basic.gonu �[��� PK ! ����S S d� typeterm_test.gonu �[��� PK ! ��7� �� util_test.gonu �[��� PK ! q�ʛ� � ;� struct.gonu �[��� PK ! (d��m m � hilbert_test.gonu �[��� PK ! ��& � named_test.gonu �[��� PK ! J��~{ { pointer.gonu �[��� PK ! ٌ��� � � universe.gonu �[��� PK ! ��� @ @ �& assignments.gonu �[��� PK ! ��~} g selection.gonu �[��� PK ! UrI1� � t~ util.gonu �[��� PK ! I��m m �� builtins.gonu �[��� PK ! B�%�^ ^ �� sizes_test.gonu �[��� PK ! I C+[h [h �� api_test.gonu �[��� PK ! 94� � � -h resolver_test.gonu �[��� PK ! ��� [{ typeterm.gonu �[��� PK ! �EAWs Ws �� decl.gonu �[��� PK ! �9�Y Y 7� self_test.gonu �[��� PK ! ����m �m � unify.gonu �[��� PK ! �ekA�+ �+ �v operand.gonu �[��� PK ! �v v� � � termlist_test.gonu �[��� PK ! I?�� � �� tuple.gonu �[��� PK ! F�nX�� �� �� call.gonu �[��� PK ! ��r.? .? �D typexpr.gonu �[��� PK ! �t�Vg Vg �� resolver.gonu �[��� PK ! {�ս^ ^ �� typelists.gonu �[��� PK ! �*��c+ c+ )� builtins_test.gonu �[��� PK ! 4G�H4 4 � context.gonu �[��� PK ! ��8��K �K :0 object.gonu �[��� PK ! �j� � p| errors.gonu �[��� PK ! � �� � Z� lookup_test.gonu �[��� PK ! �xB�2 �2 X� signature.gonu �[��� PK ! *�:# :# �� conversions.gonu �[��� PK ! � 5� � � chan.gonu �[��� PK ! �J�%�B �B � predicates.gonu �[��� PK ! X1z�� � �> typeparam.gonu �[��� PK ! �� �# �# R validtype.gonu �[��� PK ! �c!�� � �u typeset_test.gonu �[��� PK ! C�Ke$ e$ � mono.gonu �[��� PK ! ����/ �/ m� instantiate.gonu �[��� PK ! �V� 2 2 �� compilersupport.gonu �[��� PK ! �x� �� gccgosizes.gonu �[��� PK ! ��X/ X/ D� typestring.gonu �[��� PK ! �Z� � testdata/manual.gonu �[��� PK ! �\ìC C 8 testdata/local/issue47996.gonu �[��� PK ! 2��$A A � slice.gonu �[��� PK ! �� � @ errorcalls_test.gonu �[��� PK ! zd�� � L gcsizes.gonu �[��� PK ! /�>v� � g, api_predicates.gonu �[��� PK ! ;��4 4 �7 context_test.gonu �[��� PK ! dv���4 �4 �@ stdlib_test.gonu �[��� PK ! do� � 8v object_test.gonu �[��� PK ! 8{�� � � version.gonu �[��� PK Y Y 9 �
| ver. 1.1 | |
.
| PHP 8.4.18 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0.29 |
proxy
|
phpinfo
|
ÐаÑтройка