Source file src/go/types/decl.go

Documentation: go/types

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package types
     6  
     7  import (
     8  	"go/ast"
     9  	"go/constant"
    10  	"go/token"
    11  )
    12  
    13  func (check *Checker) reportAltDecl(obj Object) {
    14  	if pos := obj.Pos(); pos.IsValid() {
    15  		// We use "other" rather than "previous" here because
    16  		// the first declaration seen may not be textually
    17  		// earlier in the source.
    18  		check.errorf(pos, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
    19  	}
    20  }
    21  
    22  func (check *Checker) declare(scope *Scope, id *ast.Ident, obj Object, pos token.Pos) {
    23  	// spec: "The blank identifier, represented by the underscore
    24  	// character _, may be used in a declaration like any other
    25  	// identifier but the declaration does not introduce a new
    26  	// binding."
    27  	if obj.Name() != "_" {
    28  		if alt := scope.Insert(obj); alt != nil {
    29  			check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
    30  			check.reportAltDecl(alt)
    31  			return
    32  		}
    33  		obj.setScopePos(pos)
    34  	}
    35  	if id != nil {
    36  		check.recordDef(id, obj)
    37  	}
    38  }
    39  
    40  // pathString returns a string of the form a->b-> ... ->g for a path [a, b, ... g].
    41  // TODO(gri) remove once we don't need the old cycle detection (explicitly passed
    42  //           []*TypeName path) anymore
    43  func pathString(path []*TypeName) string {
    44  	var s string
    45  	for i, p := range path {
    46  		if i > 0 {
    47  			s += "->"
    48  		}
    49  		s += p.Name()
    50  	}
    51  	return s
    52  }
    53  
    54  // objPathString returns a string of the form a->b-> ... ->g for a path [a, b, ... g].
    55  // TODO(gri) s/objPathString/pathString/ once we got rid of pathString above
    56  func objPathString(path []Object) string {
    57  	var s string
    58  	for i, p := range path {
    59  		if i > 0 {
    60  			s += "->"
    61  		}
    62  		s += p.Name()
    63  	}
    64  	return s
    65  }
    66  
    67  // objDecl type-checks the declaration of obj in its respective (file) context.
    68  // For the meaning of def, see Checker.definedType, in typexpr.go.
    69  func (check *Checker) objDecl(obj Object, def *Named) {
    70  	if trace {
    71  		check.trace(obj.Pos(), "-- checking %s %s (objPath = %s)", obj.color(), obj, objPathString(check.objPath))
    72  		check.indent++
    73  		defer func() {
    74  			check.indent--
    75  			check.trace(obj.Pos(), "=> %s", obj)
    76  		}()
    77  	}
    78  
    79  	// Checking the declaration of obj means inferring its type
    80  	// (and possibly its value, for constants).
    81  	// An object's type (and thus the object) may be in one of
    82  	// three states which are expressed by colors:
    83  	//
    84  	// - an object whose type is not yet known is painted white (initial color)
    85  	// - an object whose type is in the process of being inferred is painted grey
    86  	// - an object whose type is fully inferred is painted black
    87  	//
    88  	// During type inference, an object's color changes from white to grey
    89  	// to black (pre-declared objects are painted black from the start).
    90  	// A black object (i.e., its type) can only depend on (refer to) other black
    91  	// ones. White and grey objects may depend on white and black objects.
    92  	// A dependency on a grey object indicates a cycle which may or may not be
    93  	// valid.
    94  	//
    95  	// When objects turn grey, they are pushed on the object path (a stack);
    96  	// they are popped again when they turn black. Thus, if a grey object (a
    97  	// cycle) is encountered, it is on the object path, and all the objects
    98  	// it depends on are the remaining objects on that path. Color encoding
    99  	// is such that the color value of a grey object indicates the index of
   100  	// that object in the object path.
   101  
   102  	// During type-checking, white objects may be assigned a type without
   103  	// traversing through objDecl; e.g., when initializing constants and
   104  	// variables. Update the colors of those objects here (rather than
   105  	// everywhere where we set the type) to satisfy the color invariants.
   106  	if obj.color() == white && obj.Type() != nil {
   107  		obj.setColor(black)
   108  		return
   109  	}
   110  
   111  	switch obj.color() {
   112  	case white:
   113  		assert(obj.Type() == nil)
   114  		// All color values other than white and black are considered grey.
   115  		// Because black and white are < grey, all values >= grey are grey.
   116  		// Use those values to encode the object's index into the object path.
   117  		obj.setColor(grey + color(check.push(obj)))
   118  		defer func() {
   119  			check.pop().setColor(black)
   120  		}()
   121  
   122  	case black:
   123  		assert(obj.Type() != nil)
   124  		return
   125  
   126  	default:
   127  		// Color values other than white or black are considered grey.
   128  		fallthrough
   129  
   130  	case grey:
   131  		// We have a cycle.
   132  		// In the existing code, this is marked by a non-nil type
   133  		// for the object except for constants and variables whose
   134  		// type may be non-nil (known), or nil if it depends on the
   135  		// not-yet known initialization value.
   136  		// In the former case, set the type to Typ[Invalid] because
   137  		// we have an initialization cycle. The cycle error will be
   138  		// reported later, when determining initialization order.
   139  		// TODO(gri) Report cycle here and simplify initialization
   140  		// order code.
   141  		switch obj := obj.(type) {
   142  		case *Const:
   143  			if check.typeCycle(obj) || obj.typ == nil {
   144  				obj.typ = Typ[Invalid]
   145  			}
   146  
   147  		case *Var:
   148  			if check.typeCycle(obj) || obj.typ == nil {
   149  				obj.typ = Typ[Invalid]
   150  			}
   151  
   152  		case *TypeName:
   153  			if check.typeCycle(obj) {
   154  				// break cycle
   155  				// (without this, calling underlying()
   156  				// below may lead to an endless loop
   157  				// if we have a cycle for a defined
   158  				// (*Named) type)
   159  				obj.typ = Typ[Invalid]
   160  			}
   161  
   162  		case *Func:
   163  			if check.typeCycle(obj) {
   164  				// Don't set obj.typ to Typ[Invalid] here
   165  				// because plenty of code type-asserts that
   166  				// functions have a *Signature type. Grey
   167  				// functions have their type set to an empty
   168  				// signature which makes it impossible to
   169  				// initialize a variable with the function.
   170  			}
   171  
   172  		default:
   173  			unreachable()
   174  		}
   175  		assert(obj.Type() != nil)
   176  		return
   177  	}
   178  
   179  	d := check.objMap[obj]
   180  	if d == nil {
   181  		check.dump("%v: %s should have been declared", obj.Pos(), obj)
   182  		unreachable()
   183  	}
   184  
   185  	// save/restore current context and setup object context
   186  	defer func(ctxt context) {
   187  		check.context = ctxt
   188  	}(check.context)
   189  	check.context = context{
   190  		scope: d.file,
   191  	}
   192  
   193  	// Const and var declarations must not have initialization
   194  	// cycles. We track them by remembering the current declaration
   195  	// in check.decl. Initialization expressions depending on other
   196  	// consts, vars, or functions, add dependencies to the current
   197  	// check.decl.
   198  	switch obj := obj.(type) {
   199  	case *Const:
   200  		check.decl = d // new package-level const decl
   201  		check.constDecl(obj, d.typ, d.init)
   202  	case *Var:
   203  		check.decl = d // new package-level var decl
   204  		check.varDecl(obj, d.lhs, d.typ, d.init)
   205  	case *TypeName:
   206  		// invalid recursive types are detected via path
   207  		check.typeDecl(obj, d.typ, def, d.alias)
   208  	case *Func:
   209  		// functions may be recursive - no need to track dependencies
   210  		check.funcDecl(obj, d)
   211  	default:
   212  		unreachable()
   213  	}
   214  }
   215  
   216  // indir is a sentinel type name that is pushed onto the object path
   217  // to indicate an "indirection" in the dependency from one type name
   218  // to the next. For instance, for "type p *p" the object path contains
   219  // p followed by indir, indicating that there's an indirection *p.
   220  // Indirections are used to break type cycles.
   221  var indir = NewTypeName(token.NoPos, nil, "*", nil)
   222  
   223  // typeCycle checks if the cycle starting with obj is valid and
   224  // reports an error if it is not.
   225  // TODO(gri) rename s/typeCycle/cycle/ once we don't need the other
   226  // cycle method anymore.
   227  func (check *Checker) typeCycle(obj Object) (isCycle bool) {
   228  	// The object map contains the package scope objects and the non-interface methods.
   229  	if debug {
   230  		info := check.objMap[obj]
   231  		inObjMap := info != nil && (info.fdecl == nil || info.fdecl.Recv == nil) // exclude methods
   232  		isPkgObj := obj.Parent() == check.pkg.scope
   233  		if isPkgObj != inObjMap {
   234  			check.dump("%v: inconsistent object map for %s (isPkgObj = %v, inObjMap = %v)", obj.Pos(), obj, isPkgObj, inObjMap)
   235  			unreachable()
   236  		}
   237  	}
   238  
   239  	// Given the number of constants and variables (nval) in the cycle
   240  	// and the cycle length (ncycle = number of named objects in the cycle),
   241  	// we distinguish between cycles involving only constants and variables
   242  	// (nval = ncycle), cycles involving types (and functions) only
   243  	// (nval == 0), and mixed cycles (nval != 0 && nval != ncycle).
   244  	// We ignore functions at the moment (taking them into account correctly
   245  	// is complicated and it doesn't improve error reporting significantly).
   246  	//
   247  	// A cycle must have at least one indirection and one type definition
   248  	// to be permitted: If there is no indirection, the size of the type
   249  	// cannot be computed (it's either infinite or 0); if there is no type
   250  	// definition, we have a sequence of alias type names which will expand
   251  	// ad infinitum.
   252  	var nval, ncycle int
   253  	var hasIndir, hasTDef bool
   254  	assert(obj.color() >= grey)
   255  	start := obj.color() - grey // index of obj in objPath
   256  	cycle := check.objPath[start:]
   257  	ncycle = len(cycle) // including indirections
   258  	for _, obj := range cycle {
   259  		switch obj := obj.(type) {
   260  		case *Const, *Var:
   261  			nval++
   262  		case *TypeName:
   263  			if obj == indir {
   264  				ncycle-- // don't count (indirections are not objects)
   265  				hasIndir = true
   266  			} else {
   267  				// Determine if the type name is an alias or not. For
   268  				// package-level objects, use the object map which
   269  				// provides syntactic information (which doesn't rely
   270  				// on the order in which the objects are set up). For
   271  				// local objects, we can rely on the order, so use
   272  				// the object's predicate.
   273  				// TODO(gri) It would be less fragile to always access
   274  				// the syntactic information. We should consider storing
   275  				// this information explicitly in the object.
   276  				var alias bool
   277  				if d := check.objMap[obj]; d != nil {
   278  					alias = d.alias // package-level object
   279  				} else {
   280  					alias = obj.IsAlias() // function local object
   281  				}
   282  				if !alias {
   283  					hasTDef = true
   284  				}
   285  			}
   286  		case *Func:
   287  			// ignored for now
   288  		default:
   289  			unreachable()
   290  		}
   291  	}
   292  
   293  	if trace {
   294  		check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", objPathString(cycle), obj.Name(), ncycle)
   295  		check.trace(obj.Pos(), "## cycle contains: %d values, has indirection = %v, has type definition = %v", nval, hasIndir, hasTDef)
   296  		defer func() {
   297  			if isCycle {
   298  				check.trace(obj.Pos(), "=> error: cycle is invalid")
   299  			}
   300  		}()
   301  	}
   302  
   303  	// A cycle involving only constants and variables is invalid but we
   304  	// ignore them here because they are reported via the initialization
   305  	// cycle check.
   306  	if nval == ncycle {
   307  		return false
   308  	}
   309  
   310  	// A cycle involving only types (and possibly functions) must have at
   311  	// least one indirection and one type definition to be permitted: If
   312  	// there is no indirection, the size of the type cannot be computed
   313  	// (it's either infinite or 0); if there is no type definition, we
   314  	// have a sequence of alias type names which will expand ad infinitum.
   315  	if nval == 0 && hasIndir && hasTDef {
   316  		return false // cycle is permitted
   317  	}
   318  
   319  	// report cycle
   320  	check.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name())
   321  	for _, obj := range cycle {
   322  		if obj == indir {
   323  			continue // don't print indir sentinels
   324  		}
   325  		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
   326  	}
   327  	check.errorf(obj.Pos(), "\t%s", obj.Name())
   328  
   329  	return true
   330  }
   331  
   332  func (check *Checker) constDecl(obj *Const, typ, init ast.Expr) {
   333  	assert(obj.typ == nil)
   334  
   335  	// use the correct value of iota
   336  	check.iota = obj.val
   337  	defer func() { check.iota = nil }()
   338  
   339  	// provide valid constant value under all circumstances
   340  	obj.val = constant.MakeUnknown()
   341  
   342  	// determine type, if any
   343  	if typ != nil {
   344  		t := check.typ(typ)
   345  		if !isConstType(t) {
   346  			// don't report an error if the type is an invalid C (defined) type
   347  			// (issue #22090)
   348  			if t.Underlying() != Typ[Invalid] {
   349  				check.errorf(typ.Pos(), "invalid constant type %s", t)
   350  			}
   351  			obj.typ = Typ[Invalid]
   352  			return
   353  		}
   354  		obj.typ = t
   355  	}
   356  
   357  	// check initialization
   358  	var x operand
   359  	if init != nil {
   360  		check.expr(&x, init)
   361  	}
   362  	check.initConst(obj, &x)
   363  }
   364  
   365  func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
   366  	assert(obj.typ == nil)
   367  
   368  	// determine type, if any
   369  	if typ != nil {
   370  		obj.typ = check.typ(typ)
   371  		// We cannot spread the type to all lhs variables if there
   372  		// are more than one since that would mark them as checked
   373  		// (see Checker.objDecl) and the assignment of init exprs,
   374  		// if any, would not be checked.
   375  		//
   376  		// TODO(gri) If we have no init expr, we should distribute
   377  		// a given type otherwise we need to re-evalate the type
   378  		// expr for each lhs variable, leading to duplicate work.
   379  	}
   380  
   381  	// check initialization
   382  	if init == nil {
   383  		if typ == nil {
   384  			// error reported before by arityMatch
   385  			obj.typ = Typ[Invalid]
   386  		}
   387  		return
   388  	}
   389  
   390  	if lhs == nil || len(lhs) == 1 {
   391  		assert(lhs == nil || lhs[0] == obj)
   392  		var x operand
   393  		check.expr(&x, init)
   394  		check.initVar(obj, &x, "variable declaration")
   395  		return
   396  	}
   397  
   398  	if debug {
   399  		// obj must be one of lhs
   400  		found := false
   401  		for _, lhs := range lhs {
   402  			if obj == lhs {
   403  				found = true
   404  				break
   405  			}
   406  		}
   407  		if !found {
   408  			panic("inconsistent lhs")
   409  		}
   410  	}
   411  
   412  	// We have multiple variables on the lhs and one init expr.
   413  	// Make sure all variables have been given the same type if
   414  	// one was specified, otherwise they assume the type of the
   415  	// init expression values (was issue #15755).
   416  	if typ != nil {
   417  		for _, lhs := range lhs {
   418  			lhs.typ = obj.typ
   419  		}
   420  	}
   421  
   422  	check.initVars(lhs, []ast.Expr{init}, token.NoPos)
   423  }
   424  
   425  // underlying returns the underlying type of typ; possibly by following
   426  // forward chains of named types. Such chains only exist while named types
   427  // are incomplete.
   428  func underlying(typ Type) Type {
   429  	for {
   430  		n, _ := typ.(*Named)
   431  		if n == nil {
   432  			break
   433  		}
   434  		typ = n.underlying
   435  	}
   436  	return typ
   437  }
   438  
   439  func (n *Named) setUnderlying(typ Type) {
   440  	if n != nil {
   441  		n.underlying = typ
   442  	}
   443  }
   444  
   445  func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bool) {
   446  	assert(obj.typ == nil)
   447  
   448  	if alias {
   449  
   450  		obj.typ = Typ[Invalid]
   451  		obj.typ = check.typ(typ)
   452  
   453  	} else {
   454  
   455  		named := &Named{obj: obj}
   456  		def.setUnderlying(named)
   457  		obj.typ = named // make sure recursive type declarations terminate
   458  
   459  		// determine underlying type of named
   460  		check.definedType(typ, named)
   461  
   462  		// The underlying type of named may be itself a named type that is
   463  		// incomplete:
   464  		//
   465  		//	type (
   466  		//		A B
   467  		//		B *C
   468  		//		C A
   469  		//	)
   470  		//
   471  		// The type of C is the (named) type of A which is incomplete,
   472  		// and which has as its underlying type the named type B.
   473  		// Determine the (final, unnamed) underlying type by resolving
   474  		// any forward chain (they always end in an unnamed type).
   475  		named.underlying = underlying(named.underlying)
   476  
   477  	}
   478  
   479  	check.addMethodDecls(obj)
   480  }
   481  
   482  func (check *Checker) addMethodDecls(obj *TypeName) {
   483  	// get associated methods
   484  	// (Checker.collectObjects only collects methods with non-blank names;
   485  	// Checker.resolveBaseTypeName ensures that obj is not an alias name
   486  	// if it has attached methods.)
   487  	methods := check.methods[obj]
   488  	if methods == nil {
   489  		return
   490  	}
   491  	delete(check.methods, obj)
   492  	assert(!check.objMap[obj].alias) // don't use TypeName.IsAlias (requires fully set up object)
   493  
   494  	// use an objset to check for name conflicts
   495  	var mset objset
   496  
   497  	// spec: "If the base type is a struct type, the non-blank method
   498  	// and field names must be distinct."
   499  	base, _ := obj.typ.(*Named) // shouldn't fail but be conservative
   500  	if base != nil {
   501  		if t, _ := base.underlying.(*Struct); t != nil {
   502  			for _, fld := range t.fields {
   503  				if fld.name != "_" {
   504  					assert(mset.insert(fld) == nil)
   505  				}
   506  			}
   507  		}
   508  
   509  		// Checker.Files may be called multiple times; additional package files
   510  		// may add methods to already type-checked types. Add pre-existing methods
   511  		// so that we can detect redeclarations.
   512  		for _, m := range base.methods {
   513  			assert(m.name != "_")
   514  			assert(mset.insert(m) == nil)
   515  		}
   516  	}
   517  
   518  	// add valid methods
   519  	for _, m := range methods {
   520  		// spec: "For a base type, the non-blank names of methods bound
   521  		// to it must be unique."
   522  		assert(m.name != "_")
   523  		if alt := mset.insert(m); alt != nil {
   524  			switch alt.(type) {
   525  			case *Var:
   526  				check.errorf(m.pos, "field and method with the same name %s", m.name)
   527  			case *Func:
   528  				check.errorf(m.pos, "method %s already declared for %s", m.name, obj)
   529  			default:
   530  				unreachable()
   531  			}
   532  			check.reportAltDecl(alt)
   533  			continue
   534  		}
   535  
   536  		if base != nil {
   537  			base.methods = append(base.methods, m)
   538  		}
   539  	}
   540  }
   541  
   542  func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
   543  	assert(obj.typ == nil)
   544  
   545  	// func declarations cannot use iota
   546  	assert(check.iota == nil)
   547  
   548  	sig := new(Signature)
   549  	obj.typ = sig // guard against cycles
   550  	fdecl := decl.fdecl
   551  	check.funcType(sig, fdecl.Recv, fdecl.Type)
   552  	if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
   553  		check.errorf(fdecl.Pos(), "func init must have no arguments and no return values")
   554  		// ok to continue
   555  	}
   556  
   557  	// function body must be type-checked after global declarations
   558  	// (functions implemented elsewhere have no body)
   559  	if !check.conf.IgnoreFuncBodies && fdecl.Body != nil {
   560  		check.later(func() {
   561  			check.funcBody(decl, obj.name, sig, fdecl.Body, nil)
   562  		})
   563  	}
   564  }
   565  
   566  func (check *Checker) declStmt(decl ast.Decl) {
   567  	pkg := check.pkg
   568  
   569  	switch d := decl.(type) {
   570  	case *ast.BadDecl:
   571  		// ignore
   572  
   573  	case *ast.GenDecl:
   574  		var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
   575  		for iota, spec := range d.Specs {
   576  			switch s := spec.(type) {
   577  			case *ast.ValueSpec:
   578  				switch d.Tok {
   579  				case token.CONST:
   580  					top := len(check.delayed)
   581  
   582  					// determine which init exprs to use
   583  					switch {
   584  					case s.Type != nil || len(s.Values) > 0:
   585  						last = s
   586  					case last == nil:
   587  						last = new(ast.ValueSpec) // make sure last exists
   588  					}
   589  
   590  					// declare all constants
   591  					lhs := make([]*Const, len(s.Names))
   592  					for i, name := range s.Names {
   593  						obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(iota)))
   594  						lhs[i] = obj
   595  
   596  						var init ast.Expr
   597  						if i < len(last.Values) {
   598  							init = last.Values[i]
   599  						}
   600  
   601  						check.constDecl(obj, last.Type, init)
   602  					}
   603  
   604  					check.arityMatch(s, last)
   605  
   606  					// process function literals in init expressions before scope changes
   607  					check.processDelayed(top)
   608  
   609  					// spec: "The scope of a constant or variable identifier declared
   610  					// inside a function begins at the end of the ConstSpec or VarSpec
   611  					// (ShortVarDecl for short variable declarations) and ends at the
   612  					// end of the innermost containing block."
   613  					scopePos := s.End()
   614  					for i, name := range s.Names {
   615  						check.declare(check.scope, name, lhs[i], scopePos)
   616  					}
   617  
   618  				case token.VAR:
   619  					top := len(check.delayed)
   620  
   621  					lhs0 := make([]*Var, len(s.Names))
   622  					for i, name := range s.Names {
   623  						lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil)
   624  					}
   625  
   626  					// initialize all variables
   627  					for i, obj := range lhs0 {
   628  						var lhs []*Var
   629  						var init ast.Expr
   630  						switch len(s.Values) {
   631  						case len(s.Names):
   632  							// lhs and rhs match
   633  							init = s.Values[i]
   634  						case 1:
   635  							// rhs is expected to be a multi-valued expression
   636  							lhs = lhs0
   637  							init = s.Values[0]
   638  						default:
   639  							if i < len(s.Values) {
   640  								init = s.Values[i]
   641  							}
   642  						}
   643  						check.varDecl(obj, lhs, s.Type, init)
   644  						if len(s.Values) == 1 {
   645  							// If we have a single lhs variable we are done either way.
   646  							// If we have a single rhs expression, it must be a multi-
   647  							// valued expression, in which case handling the first lhs
   648  							// variable will cause all lhs variables to have a type
   649  							// assigned, and we are done as well.
   650  							if debug {
   651  								for _, obj := range lhs0 {
   652  									assert(obj.typ != nil)
   653  								}
   654  							}
   655  							break
   656  						}
   657  					}
   658  
   659  					check.arityMatch(s, nil)
   660  
   661  					// process function literals in init expressions before scope changes
   662  					check.processDelayed(top)
   663  
   664  					// declare all variables
   665  					// (only at this point are the variable scopes (parents) set)
   666  					scopePos := s.End() // see constant declarations
   667  					for i, name := range s.Names {
   668  						// see constant declarations
   669  						check.declare(check.scope, name, lhs0[i], scopePos)
   670  					}
   671  
   672  				default:
   673  					check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
   674  				}
   675  
   676  			case *ast.TypeSpec:
   677  				obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
   678  				// spec: "The scope of a type identifier declared inside a function
   679  				// begins at the identifier in the TypeSpec and ends at the end of
   680  				// the innermost containing block."
   681  				scopePos := s.Name.Pos()
   682  				check.declare(check.scope, s.Name, obj, scopePos)
   683  				// mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
   684  				obj.setColor(grey + color(check.push(obj)))
   685  				check.typeDecl(obj, s.Type, nil, s.Assign.IsValid())
   686  				check.pop().setColor(black)
   687  			default:
   688  				check.invalidAST(s.Pos(), "const, type, or var declaration expected")
   689  			}
   690  		}
   691  
   692  	default:
   693  		check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
   694  	}
   695  }
   696  

View as plain text