// separately so that it doesn't take up space in every reader
// instance.
- curfn *ir.Func
- locals []*ir.Name
+ curfn *ir.Func
+ locals []*ir.Name
+ closureVars []*ir.Name
funarghack bool
Cost: int32(r.len()),
CanDelayResults: r.bool(),
}
- r.addBody(name.Func)
+ r.addBody(name.Func, r.explicits)
}
} else {
- r.addBody(name.Func)
+ r.addBody(name.Func, r.explicits)
}
r.sync(syncEOF)
}
// constructed.
var todoBodies []*ir.Func
-// Keep in sync with writer.implicitTypes
-// Also see comment there for why r.implicits and r.explicits should
-// never both be non-empty.
-func (r *reader) implicitTypes() []*types.Type {
- r.sync(syncImplicitTypes)
-
- implicits := r.implicits
- if len(implicits) == 0 {
- implicits = r.explicits
- } else {
- assert(len(r.explicits) == 0)
- }
- return implicits
-}
-
-func (r *reader) addBody(fn *ir.Func) {
- r.sync(syncAddBody)
-
- implicits := r.implicitTypes()
+func (r *reader) addBody(fn *ir.Func, implicits []*types.Type) {
pri := pkgReaderIndex{r.p, r.reloc(relocBody), implicits}
bodyReader[fn] = pri
func (r *reader) funcBody(fn *ir.Func) {
r.curfn = fn
- r.locals = fn.ClosureVars
+ r.closureVars = fn.ClosureVars
// TODO(mdempsky): Get rid of uses of typecheck.NodAddrAt so we
// don't have to set ir.CurFunc.
func (r *reader) useLocal() *ir.Name {
r.sync(syncUseObjLocal)
- return r.locals[r.len()]
+ if r.bool() {
+ return r.locals[r.len()]
+ }
+ return r.closureVars[r.len()]
}
func (r *reader) openScope() {
case stmtAssign:
pos := r.pos()
- names, lhs := r.assignList()
+
+ // TODO(mdempsky): After quirks mode is gone, swap these
+ // statements so we visit LHS before RHS again.
rhs := r.exprList()
+ names, lhs := r.assignList()
if len(rhs) == 0 {
for _, name := range names {
if r.bool() {
pos := r.pos()
- names, lhs := r.assignList()
+
+ // TODO(mdempsky): After quirks mode is gone, swap these
+ // statements so we read LHS before X again.
x := r.expr()
+ names, lhs := r.assignList()
+
body := r.blockStmt()
r.closeAnotherScope()
r.setType(cv, outer.Type())
}
- r.addBody(fn)
+ r.addBody(fn, r.implicits)
return fn.OClosure
}
r.inlTreeIndex = inlIndex
r.inlPosBases = make(map[*src.PosBase]*src.PosBase)
- for _, cv := range r.inlFunc.ClosureVars {
- r.locals = append(r.locals, cv.Outer)
+ r.closureVars = make([]*ir.Name, len(r.inlFunc.ClosureVars))
+ for i, cv := range r.inlFunc.ClosureVars {
+ r.closureVars[i] = cv.Outer
}
r.funcargs(fn)
explicitIdx map[*types2.TypeParam]int
// variables declared within this function
- localsIdx map[types2.Object]int
+ localsIdx map[*types2.Var]int
+
+ closureVars []posObj
+ closureVarsIdx map[*types2.Var]int
}
func (pw *pkgWriter) newWriter(k reloc, marker syncMarker) *writer {
}
}
+ sig, block := obj.Type().(*types2.Signature), decl.Body
+ body, closureVars := w.p.bodyIdx(w.p.curpkg, sig, block, w.explicitIdx)
+ assert(len(closureVars) == 0)
+
w.sync(syncFuncExt)
w.pragmaFlag(pragma)
w.linkname(obj)
w.bool(false) // stub extension
- w.addBody(obj.Type().(*types2.Signature), decl.Body, make(map[types2.Object]int))
+ w.reloc(relocBody, body)
w.sync(syncEOF)
}
// @@@ Function bodies
-func (w *writer) implicitTypes() map[*types2.TypeParam]int {
- w.sync(syncImplicitTypes)
-
- // TODO(mdempsky): Theoretically, I think at this point we want to
- // extend the implicit type parameters list with any new explicit
- // type parameters.
- //
- // However, I believe that's moot: declared functions and methods
- // have explicit type parameters, but are always declared at package
- // scope (which has no implicit type parameters); and function
- // literals can appear within a type-parameterized function (i.e.,
- // implicit type parameters), but cannot have explicit type
- // parameters of their own.
- //
- // So I think it's safe to just use whichever is non-empty.
- implicitIdx := w.implicitIdx
- if len(implicitIdx) == 0 {
- implicitIdx = w.explicitIdx
- } else {
- assert(len(w.explicitIdx) == 0)
- }
- return implicitIdx
-}
-
-func (w *writer) addBody(sig *types2.Signature, block *syntax.BlockStmt, localsIdx map[types2.Object]int) {
- w.sync(syncAddBody)
-
- implicits := w.implicitTypes()
- w.reloc(relocBody, w.p.bodyIdx(w.p.curpkg, sig, block, implicits, localsIdx))
-}
-
-func (pw *pkgWriter) bodyIdx(pkg *types2.Package, sig *types2.Signature, block *syntax.BlockStmt, implicitIdx map[*types2.TypeParam]int, localsIdx map[types2.Object]int) int {
+func (pw *pkgWriter) bodyIdx(pkg *types2.Package, sig *types2.Signature, block *syntax.BlockStmt, implicitIdx map[*types2.TypeParam]int) (idx int, closureVars []posObj) {
w := pw.newWriter(relocBody, syncFuncBody)
w.implicitIdx = implicitIdx
- w.localsIdx = localsIdx
w.funcargs(sig)
if w.bool(block != nil) {
w.pos(block.Rbrace)
}
- return w.flush()
+ return w.flush(), w.closureVars
}
func (w *writer) funcargs(sig *types2.Signature) {
}
}
-func (w *writer) addLocal(obj types2.Object) {
+func (w *writer) addLocal(obj *types2.Var) {
w.sync(syncAddLocal)
idx := len(w.localsIdx)
if enableSync {
w.int(idx)
}
+ if w.localsIdx == nil {
+ w.localsIdx = make(map[*types2.Var]int)
+ }
w.localsIdx[obj] = idx
}
-func (w *writer) useLocal(obj types2.Object) {
+func (w *writer) useLocal(pos syntax.Pos, obj *types2.Var) {
w.sync(syncUseObjLocal)
- idx, ok := w.localsIdx[obj]
- assert(ok)
+
+ if idx, ok := w.localsIdx[obj]; w.bool(ok) {
+ w.len(idx)
+ return
+ }
+
+ idx, ok := w.closureVarsIdx[obj]
+ if !ok {
+ if w.closureVarsIdx == nil {
+ w.closureVarsIdx = make(map[*types2.Var]int)
+ }
+ idx = len(w.closureVars)
+ w.closureVars = append(w.closureVars, posObj{pos, obj})
+ w.closureVarsIdx[obj] = idx
+ }
w.len(idx)
}
default:
w.code(stmtAssign)
w.pos(stmt)
- w.assignList(stmt.Lhs)
w.exprList(stmt.Rhs)
+ w.assignList(stmt.Lhs)
}
case *syntax.BlockStmt:
for _, expr := range exprs {
if name, ok := expr.(*syntax.Name); ok && name.Value != "_" {
if obj, ok := w.p.info.Defs[name]; ok {
+ obj := obj.(*types2.Var)
+
w.bool(true)
w.pos(obj)
w.localIdent(obj)
for i, name := range decl.NameList {
w.code(stmtAssign)
w.pos(decl)
- w.assignList(name)
w.exprList(values[i])
+ w.assignList(name)
}
break
}
w.code(stmtAssign)
w.pos(decl)
- w.assignList(namesAsExpr(decl.NameList))
w.exprList(decl.Values)
+ w.assignList(namesAsExpr(decl.NameList))
}
}
if rang, ok := stmt.Init.(*syntax.RangeClause); w.bool(ok) {
w.pos(rang)
- w.assignList(rang.Lhs)
w.expr(rang.X)
+ w.assignList(rang.Lhs)
} else {
w.pos(stmt)
w.stmt(stmt.Init)
}
if obj != nil {
- if _, ok := w.localsIdx[obj]; ok {
- assert(len(targs) == 0)
- w.code(exprLocal)
- w.useLocal(obj)
+ if isGlobal(obj) {
+ w.code(exprName)
+ w.obj(obj, targs)
return
}
- w.code(exprName)
- w.obj(obj, targs)
+ obj := obj.(*types2.Var)
+ assert(len(targs) == 0)
+
+ w.code(exprLocal)
+ w.useLocal(expr.Pos(), obj)
return
}
w.pos(expr.Type) // for QuirksMode
w.signature(sig)
- closureVars, localsIdx := w.captureVars(expr)
+ block := expr.Body
+ body, closureVars := w.p.bodyIdx(w.p.curpkg, sig, block, w.implicitIdx)
+
w.len(len(closureVars))
- for _, closureVar := range closureVars {
- w.pos(closureVar.pos)
- w.useLocal(closureVar.obj)
+ for _, cv := range closureVars {
+ w.pos(cv.pos)
+ if quirksMode() {
+ cv.pos = expr.Body.Rbrace
+ }
+ w.useLocal(cv.pos, cv.obj)
}
- w.addBody(sig, expr.Body, localsIdx)
+ w.reloc(relocBody, body)
}
type posObj struct {
pos syntax.Pos
- obj types2.Object
-}
-
-// captureVars returns the free variables used by the given function
-// literal. The closureVars result is the list of free variables
-// captured by expr, and localsIdx is a map from free variable to
-// index. See varCaptor's identically named fields for more details.
-func (w *writer) captureVars(expr *syntax.FuncLit) (closureVars []posObj, localsIdx map[types2.Object]int) {
- scope, ok := w.p.info.Scopes[expr.Type]
- assert(ok)
-
- // TODO(mdempsky): This code needs to be cleaned up (e.g., to avoid
- // traversing nested function literals multiple times). This will be
- // easier after we drop quirks mode.
-
- v := varCaptor{
- w: w,
- scope: scope,
- localsIdx: make(map[types2.Object]int),
- }
-
- syntax.Walk(expr.Body, &v)
-
- return v.closureVars, v.localsIdx
-}
-
-// varCaptor implements syntax.Visitor for enumerating free variables
-// used by a function literal.
-type varCaptor struct {
- w *writer
- scope *types2.Scope
-
- // closureVars lists free variables along with the position where
- // they first appeared, in order of appearance.
- closureVars []posObj
-
- // localsIdx is a map from free variables to their index within
- // closureVars.
- localsIdx map[types2.Object]int
-}
-
-func (v *varCaptor) capture(n *syntax.Name) {
- obj, ok := v.w.p.info.Uses[n].(*types2.Var)
- if !ok || obj.IsField() {
- return // not a variable
- }
-
- if obj.Parent() == obj.Pkg().Scope() {
- return // global variable
- }
-
- if _, ok := v.localsIdx[obj]; ok {
- return // already captured
- }
-
- for parent := obj.Parent(); parent != obj.Pkg().Scope(); parent = parent.Parent() {
- if parent == v.scope {
- return // object declared within our scope
- }
- }
-
- idx := len(v.closureVars)
- v.closureVars = append(v.closureVars, posObj{n.Pos(), obj})
- v.localsIdx[obj] = idx
-}
-
-func (v *varCaptor) Visit(n syntax.Node) syntax.Visitor {
- // Constant expressions don't count towards capturing.
- if n, ok := n.(syntax.Expr); ok {
- if tv, ok := v.w.p.info.Types[n]; ok && tv.Value != nil {
- return nil
- }
- }
-
- if n, ok := n.(*syntax.Name); ok {
- v.capture(n)
- }
-
- if quirksMode() {
- switch n := n.(type) {
- case *syntax.FuncLit:
- // Quirk: typecheck uses the rbrace position position of the
- // function literal as the position of the intermediary capture.
- end := len(v.closureVars)
- syntax.Walk(n.Type, v) // unnecessary to walk, but consistent with non-quirks mode
- syntax.Walk(n.Body, v)
- for i := end; i < len(v.closureVars); i++ {
- v.closureVars[i].pos = n.Body.Rbrace
- }
- return nil
-
- case *syntax.AssignStmt:
- // Quirk: typecheck visits (and thus captures) the RHS of
- // assignment statements (but not op= statements) before the LHS.
- if n.Op == 0 || n.Op == syntax.Def {
- syntax.Walk(n.Rhs, v)
- syntax.Walk(n.Lhs, v)
- return nil
- }
-
- case *syntax.RangeClause:
- // Quirk: Similarly, typecheck visits the expression to be
- // iterated over before the iteration variables.
- syntax.Walk(n.X, v)
- if n.Lhs != nil {
- syntax.Walk(n.Lhs, v)
- }
- return nil
- }
- }
-
- return v
+ obj *types2.Var
}
func (w *writer) exprList(expr syntax.Expr) {