diff --git a/java_indexer/src/io/coati/JavaAstVisitor.java b/java_indexer/src/io/coati/JavaAstVisitor.java index 97347ee8..d2f839b0 100644 --- a/java_indexer/src/io/coati/JavaAstVisitor.java +++ b/java_indexer/src/io/coati/JavaAstVisitor.java @@ -19,6 +19,7 @@ import com.github.javaparser.ast.comments.LineComment; import com.github.javaparser.ast.expr.ArrayInitializerExpr; import com.github.javaparser.ast.expr.MethodCallExpr; import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.ast.expr.QualifiedNameExpr; import com.github.javaparser.ast.expr.VariableDeclarationExpr; import com.github.javaparser.ast.stmt.BlockStmt; import com.github.javaparser.ast.stmt.SwitchStmt; @@ -71,7 +72,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { NameExpr nameExpr = n.getName(); - String packageName = JavaDeclNameResolver.getQualifiedName(nameExpr).toNameHierarchy(); + String packageName = JavaparserDeclNameResolver.getQualifiedName(nameExpr).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithScope( m_callbackId, packageName, SymbolType.PACKAGE, @@ -87,7 +88,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { NameExpr nameExpr = n.getNameExpr(); - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithScope( m_callbackId, qualifiedName, (n.isInterface() ? SymbolType.INTERFACE : SymbolType.CLASS), @@ -138,7 +139,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { NameExpr nameExpr = n.getNameExpr(); - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithScope( m_callbackId, qualifiedName, SymbolType.ENUM, @@ -159,7 +160,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter @Override public void visit(final EnumConstantDeclaration n, final Void v) { - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbol( m_callbackId, qualifiedName, SymbolType.ENUM_CONSTANT, @@ -178,7 +179,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { NameExpr nameExpr = n.getNameExpr(); - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithScope( m_callbackId, qualifiedName, SymbolType.METHOD, @@ -198,7 +199,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { NameExpr nameExpr = n.getNameExpr(); - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithScope( m_callbackId, qualifiedName, SymbolType.METHOD, @@ -214,7 +215,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter me.tomassetti.symbolsolver.model.declarations.MethodDeclaration overridden = getOverridden(n, parent); if (overridden != null && (overridden instanceof JavaParserMethodDeclaration)) { - String overriddenName = JavaDeclNameResolver.getQualifiedDeclName(((JavaParserMethodDeclaration)overridden).getWrappedNode(), m_typeSolver).toNameHierarchy(); + String overriddenName = JavaparserDeclNameResolver.getQualifiedDeclName(((JavaParserMethodDeclaration)overridden).getWrappedNode(), m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordReference( m_callbackId, ReferenceKind.OVERRIDE, overriddenName, qualifiedName, @@ -306,7 +307,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter for (int i = 0; i < variableDeclarators.size(); i++) { VariableDeclarator varDecl = variableDeclarators.get(i); - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(varDecl, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(varDecl, m_typeSolver).toSerializedNameHierarchy(); VariableDeclaratorId varDeclId = varDecl.getId(); JavaIndexer.recordSymbol( @@ -363,7 +364,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter if (n.isAsterisk()) { NameExpr nameExpr = n.getName(); - String importedName = JavaDeclNameResolver.getQualifiedName(nameExpr).toNameHierarchy(); + String importedName = JavaparserDeclNameResolver.getQualifiedName(nameExpr).toSerializedNameHierarchy(); for (DeclContext context: m_context) { JavaIndexer.recordReference( @@ -378,77 +379,69 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter try { NameExpr nameExpr = n.getName(); - - JavaDeclName importedDeclName = null; - + List importedDeclNames = new ArrayList<>(); + SymbolReference symbolReference = m_typeSolver.tryToSolveType( - JavaDeclNameResolver.getQualifiedName(nameExpr).toString() + JavaparserDeclNameResolver.getQualifiedName(nameExpr).toString() ); if (symbolReference.isSolved()) { - importedDeclName = JavaDeclNameResolver.getQualifiedDeclName(symbolReference.getCorrespondingDeclaration(), m_typeSolver); + importedDeclNames.add(JavaSymbolSolverDeclNameResolver.getQualifiedDeclName( + symbolReference.getCorrespondingDeclaration(), m_typeSolver + )); } - - /* else { - // TODO: handle import of static field or method - if (nameExpr instanceof QualifiedNameExpr) { - String qName = nameExpr.toString(); - int typeNameEndIndex = qName.lastIndexOf('.'); - if (typeNameEndIndex != -1) + String typeName = ((QualifiedNameExpr)nameExpr).getQualifier().toString(); + String memberName = nameExpr.getName(); + + me.tomassetti.symbolsolver.model.declarations.TypeDeclaration ref = m_typeSolver.solveType(typeName); + + for (me.tomassetti.symbolsolver.model.declarations.MethodDeclaration methodDecl: ref.getDeclaredMethods()) // look for method { - String typeName = qName.substring(0, typeNameEndIndex); - String memberName = qName.substring(typeNameEndIndex + 1); - - me.tomassetti.symbolsolver.model.declarations.TypeDeclaration ref = m_typeSolver.solveType(typeName); - for (me.tomassetti.symbolsolver.model.declarations.MethodDeclaration methodDecl: ref.getDeclaredMethods()) // look for method + if (methodDecl.getName().equals(memberName)) { - if (methodDecl.getName().equals(memberName)) - { - System.out.println("methodDeclNamasdasdasdasd: " + methodDecl.getName()); - importedDeclName = JavaDeclNameResolver.getQualifiedDeclName(methodDecl, m_typeSolver); - break; - } + importedDeclNames.add( + JavaSymbolSolverDeclNameResolver.getQualifiedDeclName(methodDecl, m_typeSolver + )); } - if (importedDeclName == null && ref.hasField(memberName)) // look for field + } + if (importedDeclNames.isEmpty() && ref.hasField(memberName)) // look for field + { + JavaDeclName importedTypeDeclName = JavaSymbolSolverDeclNameResolver.getQualifiedDeclName(ref, m_typeSolver); + if (importedTypeDeclName != null) { - JavaDeclName importedTypeDeclName = JavaDeclNameResolver.getQualifiedDeclName(ref, m_typeSolver); - if (importedTypeDeclName != null) - { - importedDeclName = new JavaDeclName(memberName); - importedDeclName.setParent(importedTypeDeclName); - } + JavaDeclName importedDeclName = new JavaDeclName(memberName); + importedDeclName.setParent(importedTypeDeclName); + importedDeclNames.add(importedDeclName); } } } } - - */ - if (importedDeclName != null) + if (!importedDeclNames.isEmpty()) { - String importedName = importedDeclName.toNameHierarchy(); - for (DeclContext context: m_context) + for (JavaDeclName importedDeclName: importedDeclNames) { - JavaIndexer.recordReference( - m_callbackId, ReferenceKind.IMPORT, - importedName, context.getName(), - nameExpr.getBeginLine(), nameExpr.getBeginColumn(), nameExpr.getEndLine(), nameExpr.getEndColumn() - ); + String nameHierarchy = importedDeclName.toSerializedNameHierarchy(); + for (DeclContext context: m_context) + { + JavaIndexer.recordReference( + m_callbackId, ReferenceKind.IMPORT, + nameHierarchy, context.getName(), + nameExpr.getBeginLine(), nameExpr.getBeginColumn(), nameExpr.getEndLine(), nameExpr.getEndColumn() + ); + } } } else { - // uncomment this when there are no errors where there shouldn't be - /* JavaIndexer.recordError( m_callbackId, "Import not found.", true, true, nameExpr.getBeginLine(), nameExpr.getBeginColumn(), nameExpr.getEndLine(), nameExpr.getEndColumn() ); - */ } } catch (Exception e) @@ -468,7 +461,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { for (DeclContext context: m_context) { - String referencedName = JavaTypeNameResolver.getQualifiedTypeName(n, m_typeSolver).toNameHierarchy(); + String referencedName = JavaparserTypeNameResolver.getQualifiedTypeName(n, m_typeSolver).toSerializedNameHierarchy(); int beginLine = n.getBeginLine(); int beginColumn = n.getBeginColumn(); @@ -501,7 +494,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { try { - String referencedName = JavaTypeNameResolver.getQualifiedTypeName(n, m_typeSolver).toNameHierarchy(); + String referencedName = JavaparserTypeNameResolver.getQualifiedTypeName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithoutLocation( m_callbackId, referencedName, SymbolType.BUILTIN_TYPE, @@ -531,7 +524,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { try { - String referencedName = JavaTypeNameResolver.getQualifiedTypeName(n, m_typeSolver).toNameHierarchy(); + String referencedName = JavaparserTypeNameResolver.getQualifiedTypeName(n, m_typeSolver).toSerializedNameHierarchy(); JavaIndexer.recordSymbolWithoutLocation( m_callbackId, referencedName, SymbolType.BUILTIN_TYPE, @@ -603,7 +596,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter { if (getFieldDeclarationInParentHierarchy(wrappedNode) != null) { - String qualifiedName = JavaDeclNameResolver.getQualifiedDeclName((VariableDeclarator)wrappedNode, m_typeSolver).toNameHierarchy(); + String qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName((VariableDeclarator)wrappedNode, m_typeSolver).toSerializedNameHierarchy(); for (DeclContext context: m_context) { @@ -785,7 +778,7 @@ public class JavaAstVisitor extends JavaAstVisitorAdapter if (methodDecl instanceof JavaParserMethodDeclaration) { MethodDeclaration wrappedNode = ((JavaParserMethodDeclaration)methodDecl).getWrappedNode(); - qualifiedName = JavaDeclNameResolver.getQualifiedDeclName(wrappedNode, m_typeSolver).toNameHierarchy(); + qualifiedName = JavaparserDeclNameResolver.getQualifiedDeclName(wrappedNode, m_typeSolver).toSerializedNameHierarchy(); } else // todo: move this implementation somewhere else { diff --git a/java_indexer/src/io/coati/JavaDeclName.java b/java_indexer/src/io/coati/JavaDeclName.java index d40b4c4d..14bd5c6e 100644 --- a/java_indexer/src/io/coati/JavaDeclName.java +++ b/java_indexer/src/io/coati/JavaDeclName.java @@ -69,12 +69,12 @@ public class JavaDeclName return m_name; } - public String toNameHierarchy() + public String toSerializedNameHierarchy() { String nameHierarchy = ""; if (m_parent != null) { - nameHierarchy = m_parent.toNameHierarchy(); + nameHierarchy = m_parent.toSerializedNameHierarchy(); nameHierarchy += "\tn"; } diff --git a/java_indexer/src/io/coati/JavaSymbolSolverDeclNameResolver.java b/java_indexer/src/io/coati/JavaSymbolSolverDeclNameResolver.java new file mode 100644 index 00000000..214113d6 --- /dev/null +++ b/java_indexer/src/io/coati/JavaSymbolSolverDeclNameResolver.java @@ -0,0 +1,121 @@ +package io.coati; + +import java.util.ArrayList; +import java.util.List; + +import com.github.javaparser.ast.body.BodyDeclaration; +import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; +import com.github.javaparser.ast.body.Parameter; + +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration; +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserInterfaceDeclaration; +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserMethodDeclaration; +import me.tomassetti.symbolsolver.model.declarations.Declaration; +import me.tomassetti.symbolsolver.model.declarations.MethodDeclaration; +import me.tomassetti.symbolsolver.model.declarations.ParameterDeclaration; +import me.tomassetti.symbolsolver.model.declarations.TypeDeclaration; +import me.tomassetti.symbolsolver.model.resolution.TypeParameter; +import me.tomassetti.symbolsolver.model.resolution.TypeSolver; + +public class JavaSymbolSolverDeclNameResolver extends JavaNameResolver +{ + public JavaSymbolSolverDeclNameResolver(TypeSolver typeSolver, ArrayList ignoredContexts) + { + super(typeSolver, ignoredContexts); + } + + public static JavaDeclName getQualifiedDeclName(Declaration decl, TypeSolver typeSolver) + { + return getQualifiedDeclName(decl, typeSolver, null); + } + + public static JavaDeclName getQualifiedDeclName(Declaration decl, TypeSolver typeSolver, ArrayList ignoredContexts) + { + JavaSymbolSolverDeclNameResolver resolver = new JavaSymbolSolverDeclNameResolver(typeSolver, ignoredContexts); + return resolver.getQualifiedDeclName(decl); + } + + public JavaDeclName getQualifiedDeclName(Declaration decl) + { + JavaDeclName declName = null; + + if (decl != null) + { + if (decl instanceof TypeDeclaration) + { + TypeDeclaration typeDecl = (TypeDeclaration)decl; + + ClassOrInterfaceDeclaration javaparserDecl = null; + if (typeDecl instanceof JavaParserClassDeclaration) + { + javaparserDecl = ((JavaParserClassDeclaration)typeDecl).getWrappedNode(); + } + else if (typeDecl instanceof JavaParserInterfaceDeclaration) + { + javaparserDecl = ((JavaParserInterfaceDeclaration)typeDecl).getWrappedNode(); + } + + if (javaparserDecl != null) + { + declName = JavaparserDeclNameResolver.getQualifiedDeclName(javaparserDecl, m_typeSolver, m_ignoredContexts); + } + else + { + declName = JavaDeclName.fromDotSeparatedString(typeDecl.getQualifiedName()); + } + } + else if (decl instanceof MethodDeclaration) + { + MethodDeclaration methodDecl = (MethodDeclaration)decl; + + if (methodDecl instanceof JavaParserMethodDeclaration) + { + declName = JavaparserDeclNameResolver.getQualifiedDeclName( + ((JavaParserMethodDeclaration)methodDecl).getWrappedNode(), + m_typeSolver, + m_ignoredContexts + ); + } + else + { + // TODO: what about endless recursion regarding type parameters and return type?? + + List parameterNames = new ArrayList<>(); + for (int i = 0; i < methodDecl.getNoParams(); i++) + { + parameterNames.add(JavaSymbolSolverTypeNameResolver.getQualifiedTypeName( + methodDecl.getParam(i).getType(), m_typeSolver, m_ignoredContexts + )); + } + + declName = new JavaDeclName( + methodDecl.getName(), + getTypeParameterNames(methodDecl.getTypeParameters()), + JavaSymbolSolverTypeNameResolver.getQualifiedTypeName(methodDecl.getReturnType(), m_typeSolver, m_ignoredContexts), + parameterNames + ); + + declName.setParent( + getQualifiedDeclName(methodDecl.declaringType(), m_typeSolver, m_ignoredContexts) + ); + } + + } + } + return declName; + } + + private static List getTypeParameterNames(List typeParameters) + { + List typeParameterNames = new ArrayList<>(); + if (typeParameters != null && typeParameters.size() > 0) + { + for (int i = 0; i < typeParameters.size(); i++) + { + typeParameterNames.add(typeParameters.get(i).getName()); + } + } + return typeParameterNames; + } + +} diff --git a/java_indexer/src/io/coati/JavaSymbolSolverTypeNameResolver.java b/java_indexer/src/io/coati/JavaSymbolSolverTypeNameResolver.java new file mode 100644 index 00000000..dd158ecf --- /dev/null +++ b/java_indexer/src/io/coati/JavaSymbolSolverTypeNameResolver.java @@ -0,0 +1,130 @@ +package io.coati; + +import java.util.ArrayList; +import java.util.List; + +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.body.BodyDeclaration; +import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.IntersectionType; +import com.github.javaparser.ast.type.PrimitiveType; +import com.github.javaparser.ast.type.ReferenceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.type.UnionType; +import com.github.javaparser.ast.type.UnknownType; +import com.github.javaparser.ast.type.VoidType; +import com.github.javaparser.ast.type.WildcardType; + +import me.tomassetti.symbolsolver.javaparsermodel.JavaParserFacade; +import me.tomassetti.symbolsolver.javaparsermodel.LambdaArgumentTypeUsagePlaceholder; +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration; +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserInterfaceDeclaration; +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserMethodDeclaration; +import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserTypeParameter; +import me.tomassetti.symbolsolver.model.declarations.Declaration; +import me.tomassetti.symbolsolver.model.declarations.MethodDeclaration; +import me.tomassetti.symbolsolver.model.declarations.TypeDeclaration; +import me.tomassetti.symbolsolver.model.resolution.TypeParameter; +import me.tomassetti.symbolsolver.model.resolution.TypeSolver; +import me.tomassetti.symbolsolver.model.typesystem.ArrayTypeUsage; +import me.tomassetti.symbolsolver.model.typesystem.NullTypeUsage; +import me.tomassetti.symbolsolver.model.typesystem.PrimitiveTypeUsage; +import me.tomassetti.symbolsolver.model.typesystem.ReferenceTypeUsage; +import me.tomassetti.symbolsolver.model.typesystem.TypeParameterUsage; +import me.tomassetti.symbolsolver.model.typesystem.TypeUsage; +import me.tomassetti.symbolsolver.model.typesystem.VoidTypeUsage; +import me.tomassetti.symbolsolver.model.typesystem.WildcardUsage; + +public class JavaSymbolSolverTypeNameResolver extends JavaNameResolver +{ + public JavaSymbolSolverTypeNameResolver(TypeSolver typeSolver, ArrayList ignoredContexts) + { + super(typeSolver, ignoredContexts); + } + + public static JavaTypeName getQualifiedTypeName(TypeUsage typeUsage, TypeSolver typeSolver) + { + return getQualifiedTypeName(typeUsage, typeSolver, null); + } + + public static JavaTypeName getQualifiedTypeName(TypeUsage typeUsage, TypeSolver typeSolver, ArrayList ignoredContexts) + { + JavaSymbolSolverTypeNameResolver resolver = new JavaSymbolSolverTypeNameResolver(typeSolver, ignoredContexts); + return resolver.getQualifiedTypeName(typeUsage); + } + + public JavaTypeName getQualifiedTypeName(TypeUsage typeUsage) + { + if (typeUsage instanceof ArrayTypeUsage) + { + return getQualifiedTypeName(((ArrayTypeUsage)typeUsage).getComponentType()); + } + else if (typeUsage instanceof LambdaArgumentTypeUsagePlaceholder) + { + + } + else if (typeUsage instanceof NullTypeUsage) + { + return JavaTypeName.fromDotSeparatedString(typeUsage.describe()); + } + else if (typeUsage instanceof PrimitiveTypeUsage) + { + return JavaTypeName.fromDotSeparatedString(typeUsage.describe()); + } + else if (typeUsage instanceof ReferenceTypeUsage) + { + ReferenceTypeUsage refTypeUsage = (ReferenceTypeUsage)typeUsage; + + JavaDeclName declName = JavaSymbolSolverDeclNameResolver.getQualifiedDeclName( + refTypeUsage.getTypeDeclaration(), + m_typeSolver, + m_ignoredContexts + ); + + if (declName != null) + { + List typeArgumentNames = new ArrayList<>(); + + for (TypeUsage typeArgument: refTypeUsage.parameters()) // don't know why this method is called "parameters()" + { + typeArgumentNames.add(getQualifiedTypeName(typeArgument, m_typeSolver, m_ignoredContexts)); + } + return new JavaTypeName(declName.getName(), typeArgumentNames, declName.getParent()); + } + } + else if (typeUsage instanceof TypeParameterUsage) + { + TypeParameter typeParam = ((TypeParameterUsage)typeUsage).asTypeParameter(); + if (typeParam instanceof JavaParserTypeParameter) + { + com.github.javaparser.ast.TypeParameter jpTypeParameter = ((JavaParserTypeParameter)typeParam).getWrappedNode(); + Node genericDecl = jpTypeParameter.getParentNode(); + if (genericDecl instanceof BodyDeclaration) + { + JavaDeclName genericName = null; + if (!ignoresContext((BodyDeclaration)genericDecl)) + { + genericName = JavaparserDeclNameResolver.getQualifiedDeclName((BodyDeclaration)genericDecl, m_typeSolver, m_ignoredContexts); + } + return new JavaTypeName(jpTypeParameter.getName(), genericName); + } + } + else + { + // do we need to handle using type parameters of external code? YES! so: TODO: do this! + } + } + else if (typeUsage instanceof VoidTypeUsage) + { + return JavaTypeName.fromDotSeparatedString(typeUsage.describe()); + } + else if (typeUsage instanceof WildcardUsage) + { + // TODO: implement this one + } + + System.out.println("Unable to resolve qualified name of " + typeUsage.getClass().toString() + ": " + typeUsage.toString()); + return new JavaTypeName("unresolved-type", null); + } +} diff --git a/java_indexer/src/io/coati/JavaTypeName.java b/java_indexer/src/io/coati/JavaTypeName.java index 33cd82e6..5db0c446 100644 --- a/java_indexer/src/io/coati/JavaTypeName.java +++ b/java_indexer/src/io/coati/JavaTypeName.java @@ -48,12 +48,12 @@ public class JavaTypeName return m_name; } - public String toNameHierarchy() + public String toSerializedNameHierarchy() { String nameHierarchy = ""; if (m_parent != null) { - nameHierarchy = m_parent.toNameHierarchy(); + nameHierarchy = m_parent.toSerializedNameHierarchy(); nameHierarchy += "\tn"; } diff --git a/java_indexer/src/io/coati/JavaDeclNameResolver.java b/java_indexer/src/io/coati/JavaparserDeclNameResolver.java similarity index 65% rename from java_indexer/src/io/coati/JavaDeclNameResolver.java rename to java_indexer/src/io/coati/JavaparserDeclNameResolver.java index 1340132c..792d419b 100644 --- a/java_indexer/src/io/coati/JavaDeclNameResolver.java +++ b/java_indexer/src/io/coati/JavaparserDeclNameResolver.java @@ -26,9 +26,9 @@ import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserClassDe import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserInterfaceDeclaration; import me.tomassetti.symbolsolver.model.resolution.TypeSolver; -public class JavaDeclNameResolver extends JavaNameResolver +public class JavaparserDeclNameResolver extends JavaNameResolver { - public JavaDeclNameResolver(TypeSolver typeSolver, ArrayList ignoredContexts) + public JavaparserDeclNameResolver(TypeSolver typeSolver, ArrayList ignoredContexts) { super(typeSolver, ignoredContexts); } @@ -40,7 +40,7 @@ public class JavaDeclNameResolver extends JavaNameResolver public static JavaDeclName getQualifiedDeclName(VariableDeclarator decl, TypeSolver typeSolver, ArrayList ignoredContexts) { - JavaDeclNameResolver resolver = new JavaDeclNameResolver(typeSolver, ignoredContexts); + JavaparserDeclNameResolver resolver = new JavaparserDeclNameResolver(typeSolver, ignoredContexts); return resolver.getQualifiedDeclName(decl); } @@ -88,7 +88,7 @@ public class JavaDeclNameResolver extends JavaNameResolver public static JavaDeclName getQualifiedDeclName(BodyDeclaration decl, TypeSolver typeSolver, ArrayList ignoredContexts) { - JavaDeclNameResolver resolver = new JavaDeclNameResolver(typeSolver, ignoredContexts); + JavaparserDeclNameResolver resolver = new JavaparserDeclNameResolver(typeSolver, ignoredContexts); return resolver.getQualifiedDeclName(decl); } @@ -128,110 +128,6 @@ public class JavaDeclNameResolver extends JavaNameResolver } return declName; } - - public static JavaDeclName getQualifiedDeclName(me.tomassetti.symbolsolver.model.declarations.TypeDeclaration typeDecl, TypeSolver typeSolver) - { - return getQualifiedDeclName(typeDecl, typeSolver, null); - } - - public static JavaDeclName getQualifiedDeclName(me.tomassetti.symbolsolver.model.declarations.TypeDeclaration typeDecl, TypeSolver typeSolver, ArrayList ignoredContexts) - { - JavaDeclNameResolver resolver = new JavaDeclNameResolver(typeSolver, ignoredContexts); - return resolver.getQualifiedDeclName(typeDecl); - } - - public JavaDeclName getQualifiedDeclName(me.tomassetti.symbolsolver.model.declarations.TypeDeclaration typeDecl) - { - JavaDeclName declName = null; - if (typeDecl != null) - { - ClassOrInterfaceDeclaration decl = null; - if (typeDecl instanceof JavaParserClassDeclaration) - { - decl = ((JavaParserClassDeclaration)typeDecl).getWrappedNode(); - } - else if (typeDecl instanceof JavaParserInterfaceDeclaration) - { - decl = ((JavaParserInterfaceDeclaration)typeDecl).getWrappedNode(); - } - - if (decl != null) - { - declName = JavaDeclNameResolver.getQualifiedDeclName(decl, m_typeSolver, m_ignoredContexts); - } - else - { - declName = JavaDeclName.fromDotSeparatedString(typeDecl.getQualifiedName()); - } - } - return declName; - } - - // TODO: move this to JavaSymbolSolverDeclNameResolver - /* - public static JavaDeclName getQualifiedDeclName(me.tomassetti.symbolsolver.model.declarations.MethodDeclaration methodDecl, TypeSolver typeSolver) - { - return getQualifiedDeclName(methodDecl, typeSolver, null); - } - - public static JavaDeclName getQualifiedDeclName(me.tomassetti.symbolsolver.model.declarations.MethodDeclaration methodDecl, TypeSolver typeSolver, ArrayList ignoredContexts) - { - JavaDeclNameResolver resolver = new JavaDeclNameResolver(typeSolver, ignoredContexts); - return resolver.getQualifiedDeclName(methodDecl); - } - - public JavaDeclName getQualifiedDeclName(me.tomassetti.symbolsolver.model.declarations.MethodDeclaration methodDecl) - { - JavaDeclName declName = null; - if (methodDecl != null) - { - MethodDeclaration decl = null; - if (methodDecl instanceof JavaParserMethodDeclaration) - { - decl = ((JavaParserMethodDeclaration)methodDecl).getWrappedNode(); - } - else - { - methodDecl.declaringType(); - - - String name = methodDecl.getName(); - - List typeParameters = methodDecl.getTypeParameters(); - List typeParameterNames = new ArrayList<>(); - if (typeParameters != null && typeParameters.size() > 0) - { - for (int i = 0; i < typeParameters.size(); i++) - { - typeParameterNames.add(typeParameters.get(i).getName()); - } - } - - JavaTypeName returnTypeName = methodDecl.getReturnType().; - - List parameterNames = new ArrayList<>(); - for (Parameter parameter: decl.getParameters()) - { - parameterNames.add(JavaTypeNameResolver.getQualifiedTypeName(parameter.getType(), m_typeSolver, m_ignoredContexts)); - } - - return new JavaDeclName(name, typeParameterNames, returnTypeName, parameterNames); - - - - - } - // todo: implement for JavaParserEnumDeclaration.ValuesMethod - - if (decl != null) - { - declName = JavaDeclNameResolver.getQualifiedDeclName(decl, m_typeSolver, m_ignoredContexts); - } - } - return declName; - } - - */ public JavaDeclName getDeclName(VariableDeclarator decl) { @@ -324,11 +220,11 @@ public class JavaDeclNameResolver extends JavaNameResolver String name = decl.getName(); List typeParameterNames = getTypeParameterNames(decl.getTypeParameters()); - JavaTypeName returnTypeName = JavaTypeNameResolver.getQualifiedTypeName(decl.getType(), m_typeSolver, ignoredContextsForTypes); + JavaTypeName returnTypeName = JavaparserTypeNameResolver.getQualifiedTypeName(decl.getType(), m_typeSolver, ignoredContextsForTypes); List parameterNames = new ArrayList<>(); for (Parameter parameter: decl.getParameters()) { - parameterNames.add(JavaTypeNameResolver.getQualifiedTypeName(parameter.getType(), m_typeSolver, ignoredContextsForTypes)); + parameterNames.add(JavaparserTypeNameResolver.getQualifiedTypeName(parameter.getType(), m_typeSolver, ignoredContextsForTypes)); } return new JavaDeclName(name, typeParameterNames, returnTypeName, parameterNames); diff --git a/java_indexer/src/io/coati/JavaTypeNameResolver.java b/java_indexer/src/io/coati/JavaparserTypeNameResolver.java similarity index 60% rename from java_indexer/src/io/coati/JavaTypeNameResolver.java rename to java_indexer/src/io/coati/JavaparserTypeNameResolver.java index 9fb718df..e1b395aa 100644 --- a/java_indexer/src/io/coati/JavaTypeNameResolver.java +++ b/java_indexer/src/io/coati/JavaparserTypeNameResolver.java @@ -14,9 +14,9 @@ import me.tomassetti.symbolsolver.model.resolution.TypeSolver; import me.tomassetti.symbolsolver.model.typesystem.TypeParameterUsage; import me.tomassetti.symbolsolver.model.typesystem.TypeUsage; -public class JavaTypeNameResolver extends JavaNameResolver +public class JavaparserTypeNameResolver extends JavaNameResolver { - public JavaTypeNameResolver(TypeSolver typeSolver, ArrayList ignoredContexts) + public JavaparserTypeNameResolver(TypeSolver typeSolver, ArrayList ignoredContexts) { super(typeSolver, ignoredContexts); } @@ -28,7 +28,7 @@ public class JavaTypeNameResolver extends JavaNameResolver public static JavaTypeName getQualifiedTypeName(Type type, TypeSolver typeSolver, ArrayList ignoredContexts) { - JavaTypeNameResolver resolver = new JavaTypeNameResolver(typeSolver, ignoredContexts); + JavaparserTypeNameResolver resolver = new JavaparserTypeNameResolver(typeSolver, ignoredContexts); return resolver.getQualifiedTypeName(type); } @@ -40,45 +40,9 @@ public class JavaTypeNameResolver extends JavaNameResolver { try { - TypeUsage typeUsage = JavaParserFacade.get(m_typeSolver).convert(type, type); - if (typeUsage.isReferenceType()) - { - JavaDeclName declName = JavaDeclNameResolver.getQualifiedDeclName(typeUsage.asReferenceTypeUsage().getTypeDeclaration(), m_typeSolver, m_ignoredContexts); - - if (declName != null) - { - List typeArgumentNames = new ArrayList<>(); - for (Type typeArgument: ((ClassOrInterfaceType)type).getTypeArgs()) - { - typeArgumentNames.add(getQualifiedTypeName(typeArgument, m_typeSolver, m_ignoredContexts)); - } - JavaTypeName ret = new JavaTypeName(declName.getName(), typeArgumentNames, declName.getParent()); - - return ret; - } - } - else if (typeUsage instanceof TypeParameterUsage) - { - TypeParameter typeParam = typeUsage.asTypeParameter(); - if (typeParam instanceof JavaParserTypeParameter) - { - com.github.javaparser.ast.TypeParameter jpTypeParameter = ((JavaParserTypeParameter)typeParam).getWrappedNode(); - Node genericDecl = jpTypeParameter.getParentNode(); - if (genericDecl instanceof BodyDeclaration) - { - JavaDeclName genericName = null; - if (!ignoresContext((BodyDeclaration)genericDecl)) - { - genericName = JavaDeclNameResolver.getQualifiedDeclName((BodyDeclaration)genericDecl, m_typeSolver, m_ignoredContexts); - } - return new JavaTypeName(jpTypeParameter.getName(), genericName); - } - } - else - { - // do we need to handle using type parameters of external code? - } - } + TypeUsage typeUsage = JavaParserFacade.get(m_typeSolver).convert(type, type); + + return JavaSymbolSolverTypeNameResolver.getQualifiedTypeName(typeUsage, m_typeSolver, m_ignoredContexts); } catch (Exception e) { diff --git a/setup/jars/MacOSX/java-symbol-solver-core.jar b/setup/jars/MacOSX/java-symbol-solver-core.jar index e78d6a71..5693ced3 100644 Binary files a/setup/jars/MacOSX/java-symbol-solver-core.jar and b/setup/jars/MacOSX/java-symbol-solver-core.jar differ diff --git a/setup/jars/linux/java-symbol-solver-core.jar b/setup/jars/linux/java-symbol-solver-core.jar index 6c82aef5..092bac57 100644 Binary files a/setup/jars/linux/java-symbol-solver-core.jar and b/setup/jars/linux/java-symbol-solver-core.jar differ diff --git a/setup/jars/windows/java-symbol-solver-core.jar b/setup/jars/windows/java-symbol-solver-core.jar index 2214b856..4a11bbc3 100644 Binary files a/setup/jars/windows/java-symbol-solver-core.jar and b/setup/jars/windows/java-symbol-solver-core.jar differ