github.com/FenixAra/go@v0.0.0-20170127160404-96ea0918e670/src/go/types/decl.go (about) 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 // objDecl type-checks the declaration of obj in its respective (file) context. 41 // See check.typ for the details on def and path. 42 func (check *Checker) objDecl(obj Object, def *Named, path []*TypeName) { 43 if obj.Type() != nil { 44 return // already checked - nothing to do 45 } 46 47 if trace { 48 check.trace(obj.Pos(), "-- declaring %s", obj.Name()) 49 check.indent++ 50 defer func() { 51 check.indent-- 52 check.trace(obj.Pos(), "=> %s", obj) 53 }() 54 } 55 56 d := check.objMap[obj] 57 if d == nil { 58 check.dump("%s: %s should have been declared", obj.Pos(), obj.Name()) 59 unreachable() 60 } 61 62 // save/restore current context and setup object context 63 defer func(ctxt context) { 64 check.context = ctxt 65 }(check.context) 66 check.context = context{ 67 scope: d.file, 68 } 69 70 // Const and var declarations must not have initialization 71 // cycles. We track them by remembering the current declaration 72 // in check.decl. Initialization expressions depending on other 73 // consts, vars, or functions, add dependencies to the current 74 // check.decl. 75 switch obj := obj.(type) { 76 case *Const: 77 check.decl = d // new package-level const decl 78 check.constDecl(obj, d.typ, d.init) 79 case *Var: 80 check.decl = d // new package-level var decl 81 check.varDecl(obj, d.lhs, d.typ, d.init) 82 case *TypeName: 83 // invalid recursive types are detected via path 84 check.typeDecl(obj, d.typ, def, path) 85 case *Func: 86 // functions may be recursive - no need to track dependencies 87 check.funcDecl(obj, d) 88 // Alias-related code. Keep for now. 89 // case *Alias: 90 // // aliases cannot be recursive - no need to track dependencies 91 // check.aliasDecl(obj, d) 92 default: 93 unreachable() 94 } 95 } 96 97 func (check *Checker) constDecl(obj *Const, typ, init ast.Expr) { 98 assert(obj.typ == nil) 99 100 if obj.visited { 101 obj.typ = Typ[Invalid] 102 return 103 } 104 obj.visited = true 105 106 // use the correct value of iota 107 assert(check.iota == nil) 108 check.iota = obj.val 109 defer func() { check.iota = nil }() 110 111 // provide valid constant value under all circumstances 112 obj.val = constant.MakeUnknown() 113 114 // determine type, if any 115 if typ != nil { 116 t := check.typ(typ) 117 if !isConstType(t) { 118 check.errorf(typ.Pos(), "invalid constant type %s", t) 119 obj.typ = Typ[Invalid] 120 return 121 } 122 obj.typ = t 123 } 124 125 // check initialization 126 var x operand 127 if init != nil { 128 check.expr(&x, init) 129 } 130 check.initConst(obj, &x) 131 } 132 133 func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) { 134 assert(obj.typ == nil) 135 136 if obj.visited { 137 obj.typ = Typ[Invalid] 138 return 139 } 140 obj.visited = true 141 142 // var declarations cannot use iota 143 assert(check.iota == nil) 144 145 // determine type, if any 146 if typ != nil { 147 obj.typ = check.typ(typ) 148 // We cannot spread the type to all lhs variables if there 149 // are more than one since that would mark them as checked 150 // (see Checker.objDecl) and the assignment of init exprs, 151 // if any, would not be checked. 152 // 153 // TODO(gri) If we have no init expr, we should distribute 154 // a given type otherwise we need to re-evalate the type 155 // expr for each lhs variable, leading to duplicate work. 156 } 157 158 // check initialization 159 if init == nil { 160 if typ == nil { 161 // error reported before by arityMatch 162 obj.typ = Typ[Invalid] 163 } 164 return 165 } 166 167 if lhs == nil || len(lhs) == 1 { 168 assert(lhs == nil || lhs[0] == obj) 169 var x operand 170 check.expr(&x, init) 171 check.initVar(obj, &x, "variable declaration") 172 return 173 } 174 175 if debug { 176 // obj must be one of lhs 177 found := false 178 for _, lhs := range lhs { 179 if obj == lhs { 180 found = true 181 break 182 } 183 } 184 if !found { 185 panic("inconsistent lhs") 186 } 187 } 188 189 // We have multiple variables on the lhs and one init expr. 190 // Make sure all variables have been given the same type if 191 // one was specified, otherwise they assume the type of the 192 // init expression values (was issue #15755). 193 if typ != nil { 194 for _, lhs := range lhs { 195 lhs.typ = obj.typ 196 } 197 } 198 199 check.initVars(lhs, []ast.Expr{init}, token.NoPos) 200 } 201 202 // underlying returns the underlying type of typ; possibly by following 203 // forward chains of named types. Such chains only exist while named types 204 // are incomplete. 205 func underlying(typ Type) Type { 206 for { 207 n, _ := typ.(*Named) 208 if n == nil { 209 break 210 } 211 typ = n.underlying 212 } 213 return typ 214 } 215 216 func (n *Named) setUnderlying(typ Type) { 217 if n != nil { 218 n.underlying = typ 219 } 220 } 221 222 func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, path []*TypeName) { 223 assert(obj.typ == nil) 224 225 // type declarations cannot use iota 226 assert(check.iota == nil) 227 228 named := &Named{obj: obj} 229 def.setUnderlying(named) 230 obj.typ = named // make sure recursive type declarations terminate 231 232 // determine underlying type of named 233 check.typExpr(typ, named, append(path, obj)) 234 235 // The underlying type of named may be itself a named type that is 236 // incomplete: 237 // 238 // type ( 239 // A B 240 // B *C 241 // C A 242 // ) 243 // 244 // The type of C is the (named) type of A which is incomplete, 245 // and which has as its underlying type the named type B. 246 // Determine the (final, unnamed) underlying type by resolving 247 // any forward chain (they always end in an unnamed type). 248 named.underlying = underlying(named.underlying) 249 250 // check and add associated methods 251 // TODO(gri) It's easy to create pathological cases where the 252 // current approach is incorrect: In general we need to know 253 // and add all methods _before_ type-checking the type. 254 // See https://play.golang.org/p/WMpE0q2wK8 255 check.addMethodDecls(obj) 256 } 257 258 func (check *Checker) addMethodDecls(obj *TypeName) { 259 // get associated methods 260 methods := check.methods[obj.name] 261 if len(methods) == 0 { 262 return // no methods 263 } 264 delete(check.methods, obj.name) 265 266 // use an objset to check for name conflicts 267 var mset objset 268 269 // spec: "If the base type is a struct type, the non-blank method 270 // and field names must be distinct." 271 base := obj.typ.(*Named) 272 if t, _ := base.underlying.(*Struct); t != nil { 273 for _, fld := range t.fields { 274 if fld.name != "_" { 275 assert(mset.insert(fld) == nil) 276 } 277 } 278 } 279 280 // Checker.Files may be called multiple times; additional package files 281 // may add methods to already type-checked types. Add pre-existing methods 282 // so that we can detect redeclarations. 283 for _, m := range base.methods { 284 assert(m.name != "_") 285 assert(mset.insert(m) == nil) 286 } 287 288 // type-check methods 289 for _, m := range methods { 290 // spec: "For a base type, the non-blank names of methods bound 291 // to it must be unique." 292 if m.name != "_" { 293 if alt := mset.insert(m); alt != nil { 294 switch alt.(type) { 295 case *Var: 296 check.errorf(m.pos, "field and method with the same name %s", m.name) 297 case *Func: 298 check.errorf(m.pos, "method %s already declared for %s", m.name, base) 299 default: 300 unreachable() 301 } 302 check.reportAltDecl(alt) 303 continue 304 } 305 } 306 check.objDecl(m, nil, nil) 307 // methods with blank _ names cannot be found - don't keep them 308 if m.name != "_" { 309 base.methods = append(base.methods, m) 310 } 311 } 312 } 313 314 func (check *Checker) funcDecl(obj *Func, decl *declInfo) { 315 assert(obj.typ == nil) 316 317 // func declarations cannot use iota 318 assert(check.iota == nil) 319 320 sig := new(Signature) 321 obj.typ = sig // guard against cycles 322 fdecl := decl.fdecl 323 check.funcType(sig, fdecl.Recv, fdecl.Type) 324 if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) { 325 check.errorf(fdecl.Pos(), "func init must have no arguments and no return values") 326 // ok to continue 327 } 328 329 // function body must be type-checked after global declarations 330 // (functions implemented elsewhere have no body) 331 if !check.conf.IgnoreFuncBodies && fdecl.Body != nil { 332 check.later(obj.name, decl, sig, fdecl.Body) 333 } 334 } 335 336 // original returns the original Object if obj is an Alias; 337 // otherwise it returns obj. The result is never an Alias, 338 // but it may be nil. 339 func original(obj Object) Object { 340 // an alias stands for the original object; use that one instead 341 if alias, _ := obj.(*disabledAlias); alias != nil { 342 obj = alias.orig 343 // aliases always refer to non-alias originals 344 if _, ok := obj.(*disabledAlias); ok { 345 panic("original is an alias") 346 } 347 } 348 return obj 349 } 350 351 func (check *Checker) aliasDecl(obj *disabledAlias, decl *declInfo) { 352 assert(obj.typ == nil) 353 354 // alias declarations cannot use iota 355 assert(check.iota == nil) 356 357 // assume alias is invalid to start with 358 obj.typ = Typ[Invalid] 359 360 // rhs must be package-qualified identifer pkg.sel (see also call.go: checker.selector) 361 // TODO(gri) factor this code out and share with checker.selector 362 rhs := decl.init 363 var pkg *Package 364 var sel *ast.Ident 365 if sexpr, ok := rhs.(*ast.SelectorExpr); ok { 366 if ident, ok := sexpr.X.(*ast.Ident); ok { 367 _, obj := check.scope.LookupParent(ident.Name, check.pos) 368 if pname, _ := obj.(*PkgName); pname != nil { 369 assert(pname.pkg == check.pkg) 370 check.recordUse(ident, pname) 371 pname.used = true 372 pkg = pname.imported 373 sel = sexpr.Sel 374 } 375 } 376 } 377 if pkg == nil { 378 check.errorf(rhs.Pos(), "invalid alias: %v is not a package-qualified identifier", rhs) 379 return 380 } 381 382 // qualified identifier must denote an exported object 383 orig := pkg.scope.Lookup(sel.Name) 384 if orig == nil || !orig.Exported() { 385 if !pkg.fake { 386 check.errorf(rhs.Pos(), "%s is not exported by package %s", sel.Name, pkg.name) 387 } 388 return 389 } 390 check.recordUse(sel, orig) 391 orig = original(orig) 392 393 // avoid further errors if the imported object is an alias that's broken 394 if orig == nil { 395 return 396 } 397 398 // An alias declaration must not refer to package unsafe. 399 if orig.Pkg() == Unsafe { 400 check.errorf(rhs.Pos(), "invalid alias: %s refers to package unsafe (%v)", obj.Name(), orig) 401 return 402 } 403 404 // The original must be of the same kind as the alias declaration. 405 var why string 406 switch obj.kind { 407 case token.CONST: 408 if _, ok := orig.(*Const); !ok { 409 why = "constant" 410 } 411 case token.TYPE: 412 if _, ok := orig.(*TypeName); !ok { 413 why = "type" 414 } 415 case token.VAR: 416 if _, ok := orig.(*Var); !ok { 417 why = "variable" 418 } 419 case token.FUNC: 420 if _, ok := orig.(*Func); !ok { 421 why = "function" 422 } 423 default: 424 unreachable() 425 } 426 if why != "" { 427 check.errorf(rhs.Pos(), "invalid alias: %v is not a %s", orig, why) 428 return 429 } 430 431 // alias is valid 432 obj.typ = orig.Type() 433 obj.orig = orig 434 } 435 436 func (check *Checker) declStmt(decl ast.Decl) { 437 pkg := check.pkg 438 439 switch d := decl.(type) { 440 case *ast.BadDecl: 441 // ignore 442 443 case *ast.GenDecl: 444 var last *ast.ValueSpec // last ValueSpec with type or init exprs seen 445 for iota, spec := range d.Specs { 446 switch s := spec.(type) { 447 case *ast.ValueSpec: 448 switch d.Tok { 449 case token.CONST: 450 // determine which init exprs to use 451 switch { 452 case s.Type != nil || len(s.Values) > 0: 453 last = s 454 case last == nil: 455 last = new(ast.ValueSpec) // make sure last exists 456 } 457 458 // declare all constants 459 lhs := make([]*Const, len(s.Names)) 460 for i, name := range s.Names { 461 obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(iota))) 462 lhs[i] = obj 463 464 var init ast.Expr 465 if i < len(last.Values) { 466 init = last.Values[i] 467 } 468 469 check.constDecl(obj, last.Type, init) 470 } 471 472 check.arityMatch(s, last) 473 474 // spec: "The scope of a constant or variable identifier declared 475 // inside a function begins at the end of the ConstSpec or VarSpec 476 // (ShortVarDecl for short variable declarations) and ends at the 477 // end of the innermost containing block." 478 scopePos := s.End() 479 for i, name := range s.Names { 480 check.declare(check.scope, name, lhs[i], scopePos) 481 } 482 483 case token.VAR: 484 lhs0 := make([]*Var, len(s.Names)) 485 for i, name := range s.Names { 486 lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil) 487 } 488 489 // initialize all variables 490 for i, obj := range lhs0 { 491 var lhs []*Var 492 var init ast.Expr 493 switch len(s.Values) { 494 case len(s.Names): 495 // lhs and rhs match 496 init = s.Values[i] 497 case 1: 498 // rhs is expected to be a multi-valued expression 499 lhs = lhs0 500 init = s.Values[0] 501 default: 502 if i < len(s.Values) { 503 init = s.Values[i] 504 } 505 } 506 check.varDecl(obj, lhs, s.Type, init) 507 if len(s.Values) == 1 { 508 // If we have a single lhs variable we are done either way. 509 // If we have a single rhs expression, it must be a multi- 510 // valued expression, in which case handling the first lhs 511 // variable will cause all lhs variables to have a type 512 // assigned, and we are done as well. 513 if debug { 514 for _, obj := range lhs0 { 515 assert(obj.typ != nil) 516 } 517 } 518 break 519 } 520 } 521 522 check.arityMatch(s, nil) 523 524 // declare all variables 525 // (only at this point are the variable scopes (parents) set) 526 scopePos := s.End() // see constant declarations 527 for i, name := range s.Names { 528 // see constant declarations 529 check.declare(check.scope, name, lhs0[i], scopePos) 530 } 531 532 default: 533 check.invalidAST(s.Pos(), "invalid token %s", d.Tok) 534 } 535 536 case *ast.TypeSpec: 537 obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil) 538 // spec: "The scope of a type identifier declared inside a function 539 // begins at the identifier in the TypeSpec and ends at the end of 540 // the innermost containing block." 541 scopePos := s.Name.Pos() 542 check.declare(check.scope, s.Name, obj, scopePos) 543 check.typeDecl(obj, s.Type, nil, nil) 544 545 default: 546 check.invalidAST(s.Pos(), "const, type, or var declaration expected") 547 } 548 } 549 550 default: 551 check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d) 552 } 553 }