func (pp *packageParser) fixVariableSymbol(t *st.VariableSymbol) {
// fmt.Printf("%s %s has type %T\n", pp.Package.AstPackage.Name, t.VariableType.Name(), t.VariableType)
if uts, ok := t.VariableType.(*st.UnresolvedTypeSymbol); ok {
//pp.CurrentFileName = pp.Package.FileSet.Position(uts.Declaration.Pos()).Filename
t.VariableType = pp.resolveType(uts)
pp.moveData(t.VariableType, uts)
}
pp.fixType(t.VariableType)
}
//ast.Visitor.Visit(). Looks for top-level ast.ValueSpec nodes of ast.Tree to register global vars
func (gv globalsFixVisitor) Visit(node ast.Node) ast.Visitor {
switch t := node.(type) {
case *ast.ValueSpec:
gv.Parser.parseTypeSymbol(t.Type)
for i, n := range t.Names {
var v *st.VariableSymbol
if sym, ok := gv.Parser.Package.Symbols.LookUp(n.Name, gv.Parser.CurrentFileName); !ok {
panic("Lost variable or something... " + n.Name)
} else {
v = sym.(*st.VariableSymbol)
}
var exprT st.ITypeSymbol = nil
if t.Values != nil {
exprT = gv.Parser.parseExpr(t.Values[i]).At(0).(st.ITypeSymbol)
if _, ok := v.VariableType.(*st.UnresolvedTypeSymbol); ok {
// if _, ok := exprT.(*st.UnresolvedTypeSymbol); !ok {
// fmt.Printf("%s: =)))) var %s found its type type\n", gv.Parser.Package.AstPackage.Name, v.Name())
// }
v.VariableType = exprT
}
}
if _, ok := exprT.(*st.UnresolvedTypeSymbol); ok {
fmt.Printf("warning: var %s in package %s still has unresolved type\n", v.Name(), gv.Parser.Package.AstPackage.Name)
}
if arrT, ok := v.VariableType.(*st.ArrayTypeSymbol); ok {
if arrT.Len == st.ELLIPSIS {
arrT.Len = exprT.(*st.ArrayTypeSymbol).Len
}
}
v.AddPosition(gv.Parser.Package.FileSet.Position(n.Pos()))
}
case *ast.ForStmt, *ast.FuncDecl, *ast.FuncLit, *ast.IfStmt, *ast.RangeStmt, *ast.SelectStmt, *ast.SwitchStmt, *ast.TypeSwitchStmt:
//InnerScope, omitted
return nil
}
return gv
}
