Fixed symbol parsing

Author: NickyBoy89

declaration.go

@@ -287,9 +287,14 @@ func ParseDecl(node *sitter.Node, source []byte, ctx Ctx) ast.Decl {
 			}
 
 			// Go through the types and check to see if they differ
-			for index, param := range d.Parameters {
-				paramType := methodParameters.NamedChild(index).ChildByFieldName("type").Content(source)
-				if param.OriginalType != paramType {
+			for index, param := range nodeutil.NamedChildrenOf(methodParameters) {
+				var paramType string
+				if param.Type() == "spread_parameter" {
+					paramType = param.NamedChild(0).Content(source)
+				} else {
+					paramType = param.ChildByFieldName("type").Content(source)
+				}
+				if d.Parameters[index].OriginalType != paramType {
 					return false
 				}
 			}

expression.go

@@ -169,15 +169,16 @@ func ParseExpr(node *sitter.Node, source []byte, ctx Ctx) ast.Expr {
 		argumentTypes := make([]string, objectArguments.NamedChildCount())
 		for ind, argument := range nodeutil.NamedChildrenOf(objectArguments) {
 			arguments[ind] = ParseExpr(argument, source, ctx)
+
 			// Look up each argument and find its type
 			if argument.Type() != "identifier" {
 				argumentTypes[ind] = symbol.TypeOfLiteral(argument, source)
 			} else {
 				if localDef := ctx.localScope.FindVariable(argument.Content(source)); localDef != nil {
 					argumentTypes[ind] = localDef.OriginalType
 					// Otherwise, a variable may exist as a global variable
-				} else if def := ctx.currentClass.FindField().ByOriginalName(argument.Content(source))[0]; def != nil {
-					argumentTypes[ind] = def.OriginalType
+				} else if def := ctx.currentFile.FindField().ByOriginalName(argument.Content(source)); len(def) > 0 {
+					argumentTypes[ind] = def[0].OriginalType
 				}
 			}
 		}
@@ -275,25 +276,25 @@ func ParseExpr(node *sitter.Node, source []byte, ctx Ctx) ast.Expr {
 		// TODO: This probably should be a cast function, instead of an assertion
 		return &ast.TypeAssertExpr{
 			X:    ParseExpr(node.NamedChild(1), source, ctx),
-			Type: ParseExpr(node.NamedChild(0), source, ctx),
+			Type: astutil.ParseType(node.NamedChild(0), source),
 		}
 	case "field_access":
 		// X.Sel
 		obj := node.ChildByFieldName("object")
 
 		if obj.Type() == "this" {
-			def := ctx.currentClass.FindField().ByOriginalName(node.ChildByFieldName("field").Content(source))[0]
-			if def == nil {
+			def := ctx.currentClass.FindField().ByOriginalName(node.ChildByFieldName("field").Content(source))
+			if len(def) == 0 {
 				// TODO: This field could not be found in the current class, because it exists in the superclass
 				// definition for the class
-				def = &symbol.Definition{
+				def = []*symbol.Definition{&symbol.Definition{
 					Name: node.ChildByFieldName("field").Content(source),
-				}
+				}}
 			}
 
 			return &ast.SelectorExpr{
 				X:   ParseExpr(node.ChildByFieldName("object"), source, ctx),
-				Sel: &ast.Ident{Name: def.Name},
+				Sel: &ast.Ident{Name: def[0].Name},
 			}
 		}
 		return &ast.SelectorExpr{
@@ -358,5 +359,5 @@ func ParseExpr(node *sitter.Node, source []byte, ctx Ctx) ast.Expr {
 	case "true", "false":
 		return &ast.Ident{Name: node.Content(source)}
 	}
-	return nil
+	panic("Unhandled expression: " + node.Type())
 }

statement.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 
+	"github.com/NickyBoy89/java2go/astutil"
 	"github.com/NickyBoy89/java2go/nodeutil"
 	log "github.com/sirupsen/logrus"
 	sitter "github.com/smacker/go-tree-sitter"
@@ -28,39 +29,38 @@ func TryParseStmt(node *sitter.Node, source []byte, ctx Ctx) ast.Stmt {
 	case "comment":
 		return &ast.BadStmt{}
 	case "local_variable_declaration":
-		var varTypeIndex int
+		variableType := astutil.ParseType(node.ChildByFieldName("type"), source)
+		variableDeclarator := node.ChildByFieldName("declarator")
 
-		// The first child can either be modifiers e.g `final int var = 1`, or
-		// just the variable's type
-		if node.NamedChild(0).Type() == "modifiers" {
-			varTypeIndex = 1
-		}
-
-		// The variable declarator does not have a value (ex: int value;)
-		if node.NamedChild(varTypeIndex+1).NamedChildCount() == 1 {
+		// If a variable is being declared, but not set to a value
+		// Ex: `int value;`
+		if variableDeclarator.NamedChildCount() == 1 {
 			return &ast.DeclStmt{
 				Decl: &ast.GenDecl{
 					Tok: token.VAR,
 					Specs: []ast.Spec{
 						&ast.ValueSpec{
-							Names: []*ast.Ident{ParseExpr(node.NamedChild(varTypeIndex+1).NamedChild(0), source, ctx).(*ast.Ident)},
-							Type:  ParseExpr(node.NamedChild(varTypeIndex), source, ctx),
+							Names: []*ast.Ident{ParseExpr(variableDeclarator.ChildByFieldName("name"), source, ctx).(*ast.Ident)},
+							Type:  variableType,
 						},
 					},
 				},
 			}
 		}
 
-		ctx.lastType = ParseExpr(node.NamedChild(varTypeIndex), source, ctx)
+		ctx.lastType = variableType
 
-		declaration := ParseStmt(node.NamedChild(varTypeIndex+1), source, ctx).(*ast.AssignStmt)
+		declaration := ParseStmt(variableDeclarator, source, ctx).(*ast.AssignStmt)
 
+		// Now, if a variable is assigned to `null`, we can't infer its type, so
+		// don't throw out the type information associated with it
 		var containsNull bool
 
 		// Go through the values and see if there is a `null_literal`
-		for _, child := range nodeutil.NamedChildrenOf(node.NamedChild(varTypeIndex + 1)) {
+		for _, child := range nodeutil.NamedChildrenOf(variableDeclarator) {
 			if child.Type() == "null_literal" {
 				containsNull = true
+				break
 			}
 		}
 
@@ -78,7 +78,7 @@ func TryParseStmt(node *sitter.Node, source []byte, ctx Ctx) ast.Stmt {
 					Specs: []ast.Spec{
 						&ast.ValueSpec{
 							Names:  names,
-							Type:   ParseExpr(node.NamedChild(varTypeIndex), source, ctx),
+							Type:   variableType,
 							Values: declaration.Rhs,
 						},
 					},

symbol/class_scope.go

@@ -18,7 +18,7 @@ func (cs *ClassScope) FindMethod() Finder {
 	return &cm
 }
 
-// FindField searches through the immediate class's methods to find a specific method
+// FindField searches through the immediate class's fields to find a specific field
 func (cs *ClassScope) FindField() Finder {
 	cm := classFieldFinder(*cs)
 	return &cm

symbol/file_scope.go

@@ -25,3 +25,36 @@ func (fs *FileScope) FindClass(name string) *Definition {
 	}
 	return nil
 }
+
+// FindField searches through all of the classes in a file and determines if a
+// field exists
+func (cs *FileScope) FindField() Finder {
+	cm := fileFieldFinder(*cs)
+	return &cm
+}
+
+type fileFieldFinder FileScope
+
+func findFieldsInClass(class *ClassScope, criteria func(d *Definition) bool) []*Definition {
+	defs := class.FindField().By(criteria)
+	for _, subclass := range class.Subclasses {
+		defs = append(defs, findFieldsInClass(subclass, criteria)...)
+	}
+	return defs
+}
+
+func (ff *fileFieldFinder) By(criteria func(d *Definition) bool) []*Definition {
+	return findFieldsInClass(ff.BaseClass, criteria)
+}
+
+func (ff *fileFieldFinder) ByName(name string) []*Definition {
+	return ff.By(func(d *Definition) bool {
+		return d.Name == name
+	})
+}
+
+func (ff *fileFieldFinder) ByOriginalName(originalName string) []*Definition {
+	return ff.By(func(d *Definition) bool {
+		return d.OriginalName == originalName
+	})
+}

tree_sitter.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 
+	"github.com/NickyBoy89/java2go/astutil"
 	"github.com/NickyBoy89/java2go/nodeutil"
 	"github.com/NickyBoy89/java2go/symbol"
 	log "github.com/sirupsen/logrus"
@@ -242,37 +243,19 @@ func ParseNode(node *sitter.Node, source []byte, ctx Ctx) interface{} {
 		}
 		return &ast.Field{
 			Names: []*ast.Ident{ParseExpr(node.ChildByFieldName("name"), source, ctx).(*ast.Ident)},
-			Type:  ParseExpr(node.ChildByFieldName("type"), source, ctx),
+			Type:  astutil.ParseType(node.ChildByFieldName("type"), source),
 		}
 	case "spread_parameter":
 		// The spread paramater takes a list and separates it into multiple elements
 		// Ex: addElements([]int elements...)
 
-		switch ParseExpr(node.NamedChild(0), source, ctx).(type) {
-		case *ast.StarExpr:
-			// If the parameter is a reference type (ex: ...[]*Test), then the type is
-			// a `StarExpr`, which is passed into the ellipsis
-			return &ast.Field{
-				Names: []*ast.Ident{ParseExpr(node.NamedChild(1).NamedChild(0), source, ctx).(*ast.Ident)},
-				Type: &ast.Ellipsis{
-					Elt: ParseExpr(node.NamedChild(0), source, ctx),
-				},
-			}
-		case *ast.ArrayType:
-			// Represents something such as `byte[]... name`
-			return &ast.Field{
-				Names: []*ast.Ident{ParseExpr(node.NamedChild(1).NamedChild(0), source, ctx).(*ast.Ident)},
-				Type: &ast.Ellipsis{
-					Elt: ParseExpr(node.NamedChild(0), source, ctx),
-				},
-			}
-		}
+		spreadType := node.NamedChild(0)
+		spreadDeclarator := node.NamedChild(1)
 
 		return &ast.Field{
-			Names: []*ast.Ident{ParseExpr(node.NamedChild(0), source, ctx).(*ast.Ident)},
+			Names: []*ast.Ident{ParseExpr(spreadDeclarator.ChildByFieldName("name"), source, ctx).(*ast.Ident)},
 			Type: &ast.Ellipsis{
-				// This comes as a variable declarator, but we only need need the identifier for the type
-				Elt: ParseExpr(node.NamedChild(1).NamedChild(0), source, ctx),
+				Elt: astutil.ParseType(spreadType, source),
 			},
 		}
 	case "inferred_parameters":