add test on switch on enum value

src/main/java/me/tomassetti/symbolsolver/JavaParserFacade.java

@@ -129,7 +129,7 @@ private TypeUsage getTypeConcrete(Node node, boolean solveLambdas) {
             logger.finest("getType on name expr " + node);
             Optional<Value> value = new SymbolSolver(typeSolver).solveSymbolAsValue(nameExpr.getName(), nameExpr);
             if (!value.isPresent()){
-                throw new UnsolvedSymbolException("Solving "+node, nameExpr.getName());
+                throw new UnsolvedSymbolException("FOO Solving "+node, nameExpr.getName());
             } else {
                 return value.get().getUsage();
             }

src/main/java/me/tomassetti/symbolsolver/ProjectResolver.java

@@ -91,7 +91,7 @@ private static void solve(Node node) {
                     }
                     unsupportedMap.put(line, unsupportedMap.get(line) + 1);
                     unsupported++;
-                    if (upe.getMessage() != null && upe.getMessage().startsWith("FOO")){
+                    if (upe.getMessage() != null && upe.getMessage().contains("FOO")){
                         throw upe;
                     }
                     //throw upe;
@@ -107,7 +107,10 @@ private static void solve(Node node) {
                     }
                     koMap.put(line, koMap.get(line) + 1);
                     ko++;
-                    throw re;
+                    if (re.getMessage() != null && re.getMessage().contains("FOO")){
+                        throw re;
+                    }
+                   // throw re;
                 }
             } else {
                 //System.out.println(node + " ? from " + node.getParentNode().getClass().getCanonicalName());

src/main/java/me/tomassetti/symbolsolver/javaparser/Navigator.java

@@ -6,6 +6,7 @@
 import com.github.javaparser.ast.expr.MethodCallExpr;
 import com.github.javaparser.ast.expr.NameExpr;
 import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.stmt.SwitchStmt;
 
 import java.util.Optional;
 
@@ -136,4 +137,26 @@ public static ClassOrInterfaceDeclaration demandClassOrInterface(CompilationUnit
         ClassOrInterfaceDeclaration cd = (ClassOrInterfaceDeclaration)res.get();
         return cd;
     }
+
+    public static SwitchStmt findSwitch(Node node) {
+        SwitchStmt res = findSwitchHelper(node);
+        if (res == null) {
+            throw new IllegalArgumentException();
+        } else {
+            return res;
+        }
+    }
+
+    private static SwitchStmt findSwitchHelper(Node node) {
+        if (node instanceof SwitchStmt) {
+            return (SwitchStmt)node;
+        }
+        for (Node child : node.getChildrenNodes()){
+            SwitchStmt resChild = findSwitchHelper(child);
+            if (resChild != null) {
+                return resChild;
+            }
+        }
+        return null;
+    }
 }

src/main/java/me/tomassetti/symbolsolver/model/javaparser/JavaParserFactory.java

@@ -41,6 +41,8 @@ public static Context getContext(Node node){
             return new EnumDeclarationContext((EnumDeclaration)node);
         } else if (node instanceof FieldAccessExpr) {
             return new FieldAccessContext((FieldAccessExpr) node);
+        } else if (node instanceof SwitchStmt) {
+            return new SwitchContext((SwitchStmt) node);
         } else if (node instanceof Statement) {
             return new StatementContext((Statement) node);
         } else {

src/main/java/me/tomassetti/symbolsolver/model/javaparser/UnsolvedSymbolException.java

@@ -19,16 +19,19 @@ public String toString() {
     }
 
     public UnsolvedSymbolException(Context context, String name) {
+        super("Unsolved symbol in "+context+" : "+name);
         this.context = context.toString();
         this.name = name;
     }
 
     public UnsolvedSymbolException(String context, String name) {
+        super("Unsolved symbol in "+context+" : "+name);
         this.context = context;
         this.name = name;
     }
 
     public UnsolvedSymbolException(String name) {
+        super("Unsolved symbol : "+name);
         this.context = "unknown";
         this.name = name;
     }

src/main/java/me/tomassetti/symbolsolver/model/javaparser/contexts/MethodCallExprContext.java

@@ -49,10 +49,15 @@ public Optional<MethodUsage> solveMethodAsUsage(String name, List<TypeUsage> par
                         SymbolReference<MethodDeclaration> m = ref.getCorrespondingDeclaration().solveMethod(name, parameterTypes, typeSolver);
                         if (m.isSolved()) {
                             return Optional.of(new MethodUsage(m.getCorrespondingDeclaration(), typeSolver));
+                        } else {
+                            throw new UnsolvedSymbolException(ref.getCorrespondingDeclaration().toString(), "Method "+name+" with parameterTypes "+parameterTypes);
                         }
+                    } else {
+                        throw e;
                     }
+                } else {
+                    throw e;
                 }
-                throw e;
             }
         } else {
             if (wrappedNode.getParentNode() instanceof MethodCallExpr) {

src/main/java/me/tomassetti/symbolsolver/model/javaparser/contexts/StatementContext.java

@@ -17,9 +17,9 @@
 /**
  * Created by federico on 28/07/15.
  */
-public class StatementContext extends AbstractJavaParserContext<Statement> {
+public class StatementContext<N extends Statement> extends AbstractJavaParserContext<N> {
 
-    public StatementContext(Statement wrappedNode) {
+    public StatementContext(N wrappedNode) {
         super(wrappedNode);
     }
 

src/main/java/me/tomassetti/symbolsolver/model/javaparser/contexts/SwitchContext.java

@@ -0,0 +1,34 @@
+package me.tomassetti.symbolsolver.model.javaparser.contexts;
+
+import com.github.javaparser.ast.stmt.SwitchStmt;
+import me.tomassetti.symbolsolver.JavaParserFacade;
+import me.tomassetti.symbolsolver.model.SymbolReference;
+import me.tomassetti.symbolsolver.model.TypeSolver;
+import me.tomassetti.symbolsolver.model.declarations.EnumDeclaration;
+import me.tomassetti.symbolsolver.model.declarations.ValueDeclaration;
+import me.tomassetti.symbolsolver.model.usages.TypeUsage;
+import me.tomassetti.symbolsolver.model.usages.TypeUsageOfTypeDeclaration;
+
+/**
+ * Created by federico on 24/08/15.
+ */
+public class SwitchContext extends StatementContext<SwitchStmt> {
+
+    public SwitchContext(SwitchStmt wrappedNode) {
+        super(wrappedNode);
+    }
+
+    @Override
+    public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
+        TypeUsage typeUsage = JavaParserFacade.get(typeSolver).getType(wrappedNode.getSelector());
+        if (typeUsage.isEnum()) {
+            TypeUsageOfTypeDeclaration typeUsageOfTypeDeclaration = (TypeUsageOfTypeDeclaration)typeUsage;
+            EnumDeclaration enumDeclaration = (EnumDeclaration)typeUsageOfTypeDeclaration.getTypeDeclaration();
+            if (enumDeclaration.hasField(name, typeSolver)) {
+                return SymbolReference.solved(enumDeclaration.getField(name, typeSolver));
+            }
+        }
+        return super.solveSymbol(name, typeSolver);
+    }
+
+}

src/main/java/me/tomassetti/symbolsolver/model/javaparser/declarations/JavaParserFieldDeclaration.java

@@ -3,10 +3,12 @@
 import com.github.javaparser.ast.body.EnumConstantDeclaration;
 import com.github.javaparser.ast.body.VariableDeclarator;
 import me.tomassetti.symbolsolver.JavaParserFacade;
+import me.tomassetti.symbolsolver.model.declarations.EnumDeclaration;
 import me.tomassetti.symbolsolver.model.declarations.FieldDeclaration;
 import me.tomassetti.symbolsolver.model.TypeSolver;
 import me.tomassetti.symbolsolver.model.declarations.TypeDeclaration;
 import me.tomassetti.symbolsolver.model.usages.TypeUsage;
+import me.tomassetti.symbolsolver.model.usages.TypeUsageOfTypeDeclaration;
 
 /**
  * Created by federico on 04/08/15.
@@ -32,7 +34,8 @@ public JavaParserFieldDeclaration(EnumConstantDeclaration enumConstantDeclaratio
     @Override
     public TypeUsage getType(TypeSolver typeSolver) {
         if (enumConstantDeclaration != null) {
-            throw new UnsupportedOperationException();
+            com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = (com.github.javaparser.ast.body.EnumDeclaration)enumConstantDeclaration.getParentNode();
+            return new TypeUsageOfTypeDeclaration(new JavaParserEnumDeclaration(enumDeclaration));
         } else {
             return JavaParserFacade.get(typeSolver).convert(fieldDeclaration.getType(), fieldDeclaration);
         }

src/main/java/me/tomassetti/symbolsolver/model/usages/TypeUsage.java

@@ -125,4 +125,8 @@ default TypeUsage solveGenericTypes(Context context, TypeSolver typeSolver) {
     String getQualifiedName();
 
     String prettyPrint();
+
+    default boolean isEnum() {
+        return false;
+    }
 }

src/main/java/me/tomassetti/symbolsolver/model/usages/TypeUsageOfTypeDeclaration.java

@@ -42,6 +42,11 @@ private static List<TypeUsage> deriveParams(TypeDeclaration typeDeclaration) {
         return typeDeclaration.getTypeParameters().stream().map((tp)->new TypeUsageOfTypeParameter(tp)).collect(Collectors.toList());
     }
 
+    @Override
+    public boolean isEnum() {
+        return typeDeclaration.isEnum();
+    }
+
     public TypeUsageOfTypeDeclaration(TypeDeclaration typeDeclaration, List<TypeUsage> typeParameters) {
         this.typeDeclaration = typeDeclaration;
         this.typeParameters = typeParameters;

src/main/java/me/tomassetti/symbolsolver/model/usages/WildcardUsage.java

@@ -17,6 +17,7 @@ public class WildcardUsage implements TypeUsage {
 
 
     public WildcardUsage(WildcardType type) {
+
     }
 
     @Override

src/test/java/me/tomassetti/symbolsolver/model/EnumTest.java

@@ -0,0 +1,37 @@
+package me.tomassetti.symbolsolver.model;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.stmt.SwitchStmt;
+import me.tomassetti.symbolsolver.JavaParserFacade;
+import me.tomassetti.symbolsolver.javaparser.Navigator;
+import me.tomassetti.symbolsolver.model.declarations.ValueDeclaration;
+import me.tomassetti.symbolsolver.model.typesolvers.JreTypeSolver;
+import me.tomassetti.symbolsolver.model.usages.MethodUsage;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class EnumTest extends AbstractTest {
+
+    @Test
+    public void switchOnEnum() throws ParseException {
+        CompilationUnit cu = parseSample("SwitchOnEnum");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SwitchOnEnum");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
+        SwitchStmt switchStmt = Navigator.findSwitch(method);
+        Expression expression = switchStmt.getEntries().get(0).getLabel();
+
+        SymbolReference<? extends ValueDeclaration> ref = JavaParserFacade.get(new JreTypeSolver()).solve(expression);
+        assertTrue(ref.isSolved());
+        assertEquals("SwitchOnEnum.MyEnum", ref.getCorrespondingDeclaration().getType(new JreTypeSolver()).getQualifiedName());
+    }
+
+
+
+}

src/test/resources/SwitchOnEnum.java.txt

@@ -0,0 +1,15 @@
+class SwitchOnEnum {
+
+    enum MyEnum {
+        E1, E2, E3
+    }
+
+	public void foo() {
+	    MyEnum e;
+		switch (e){
+		    case E1:
+		        break;
+		}
+	}
+
+}