Use JP Log instead of Java logging

javaparser · Oct 12, 2018 · 3f74f84 · 3f74f84
1 parent 64f9e24
commit 3f74f84
Show file tree

Hide file tree

Showing 2 changed files with 11 additions and 34 deletions.
diff --git a/...re/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java b/...re/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java
@@ -37,11 +37,9 @@
 import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
 import com.github.javaparser.symbolsolver.resolution.ConstructorResolutionLogic;
 import com.github.javaparser.symbolsolver.resolution.SymbolSolver;
+import com.github.javaparser.utils.Log;
 
 import java.util.*;
-import java.util.logging.ConsoleHandler;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
 import static com.github.javaparser.symbolsolver.javaparser.Navigator.requireParentNode;
@@ -53,15 +51,6 @@
  */
 public class JavaParserFacade {
 
-    private static Logger logger = Logger.getLogger(JavaParserFacade.class.getCanonicalName());
-
-    static {
-        logger.setLevel(Level.INFO);
-        ConsoleHandler consoleHandler = new ConsoleHandler();
-        consoleHandler.setLevel(Level.INFO);
-        logger.addHandler(consoleHandler);
-    }
-
     private static Map<TypeSolver, JavaParserFacade> instances = new WeakHashMap<>();
     private TypeSolver typeSolver;
     private SymbolSolver symbolSolver;
@@ -204,7 +193,7 @@ public SymbolReference<ResolvedConstructorDeclaration> solve(ObjectCreationExpr
         if (!classDecl.isReferenceType()) {
             return SymbolReference.unsolved(ResolvedConstructorDeclaration.class);
         }
-        SymbolReference<ResolvedConstructorDeclaration> res = ConstructorResolutionLogic.findMostApplicable(((ResolvedClassDeclaration) classDecl.asReferenceType().getTypeDeclaration()).getConstructors(), argumentTypes, typeSolver);
+        SymbolReference<ResolvedConstructorDeclaration> res = ConstructorResolutionLogic.findMostApplicable(classDecl.asReferenceType().getTypeDeclaration().getConstructors(), argumentTypes, typeSolver);
         for (LambdaArgumentTypePlaceholder placeholder : placeholders) {
             placeholder.setMethod(res);
         }
@@ -328,7 +317,7 @@ public ResolvedType getType(Node node, boolean solveLambdas) {
                     cacheWithLambdasSolved.remove(node);
                     cacheWithLambdasSolved.put(node, getType(node, true));
                 }
-                logger.finer("getType on " + node + " -> " + res);
+                Log.trace("getType on %s  -> %s" ,node, res);
             }
             return cacheWithLambdasSolved.get(node);
         } else {
@@ -340,7 +329,7 @@ public ResolvedType getType(Node node, boolean solveLambdas) {
             if (!res.isPresent()) {
                 ResolvedType resType = getTypeConcrete(node, solveLambdas);
                 cacheWithoutLambdasSolved.put(node, resType);
-                logger.finer("getType on " + node + " (no solveLambdas) -> " + res);
+                Log.trace("getType on %s (no solveLambdas) -> %s", node, res);
                 return resType;
             }
             return res.get();

diff --git a/...-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/TypeExtractor.java b/...-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/TypeExtractor.java
@@ -32,28 +32,17 @@
 import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
 import com.github.javaparser.symbolsolver.resolution.SymbolSolver;
 import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.github.javaparser.utils.Log;
 import com.google.common.collect.ImmutableList;
 
 import java.util.List;
 import java.util.Optional;
-import java.util.logging.ConsoleHandler;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 import static com.github.javaparser.symbolsolver.javaparser.Navigator.requireParentNode;
 import static com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade.solveGenericTypes;
 
 public class TypeExtractor extends DefaultVisitorAdapter {
 
-    private static Logger logger = Logger.getLogger(TypeExtractor.class.getCanonicalName());
-
-    static {
-        logger.setLevel(Level.INFO);
-        ConsoleHandler consoleHandler = new ConsoleHandler();
-        consoleHandler.setLevel(Level.INFO);
-        logger.addHandler(consoleHandler);
-    }
-
     private TypeSolver typeSolver;
     private JavaParserFacade facade;
 
@@ -273,18 +262,18 @@ public ResolvedType visit(NullLiteralExpr node, Boolean solveLambdas) {
 
     @Override
     public ResolvedType visit(MethodCallExpr node, Boolean solveLambdas) {
-        logger.finest("getType on method call " + node);
+        Log.trace("getType on method call %s", node);
         // first solve the method
         MethodUsage ref = facade.solveMethodAsUsage(node);
-        logger.finest("getType on method call " + node + " resolved to " + ref);
-        logger.finest("getType on method call " + node + " return type is " + ref.returnType());
+        Log.trace("getType on method call %s resolved to %s", node, ref);
+        Log.trace("getType on method call %s return type is %s", node, ref.returnType());
         return ref.returnType();
         // the type is the return type of the method
     }
 
     @Override
     public ResolvedType visit(NameExpr node, Boolean solveLambdas) {
-        logger.finest("getType on name expr " + node);
+        Log.trace("getType on name expr %s", node);
         Optional<Value> value = new SymbolSolver(typeSolver).solveSymbolAsValue(node.getName().getId(), node);
         if (!value.isPresent()) {
             throw new com.github.javaparser.resolution.UnsolvedSymbolException("Solving " + node, node.getName().getId());
@@ -368,7 +357,7 @@ public ResolvedType visit(LambdaExpr node, Boolean solveLambdas) {
             if (!refMethod.isSolved()) {
                 throw new com.github.javaparser.resolution.UnsolvedSymbolException(requireParentNode(node).toString(), callExpr.getName().getId());
             }
-            logger.finest("getType on lambda expr " + refMethod.getCorrespondingDeclaration().getName());
+            Log.trace("getType on lambda expr %s", refMethod.getCorrespondingDeclaration().getName());
             if (solveLambdas) {
 
                 // The type parameter referred here should be the java.util.stream.Stream.T
@@ -479,8 +468,7 @@ public ResolvedType visit(MethodReferenceExpr node, Boolean solveLambdas) {
             if (!refMethod.isSolved()) {
                 throw new com.github.javaparser.resolution.UnsolvedSymbolException(requireParentNode(node).toString(), callExpr.getName().getId());
             }
-            logger.finest("getType on method reference expr " + refMethod.getCorrespondingDeclaration().getName());
-            //logger.finest("Method param " + refMethod.getCorrespondingDeclaration().getParam(pos));
+            Log.trace("getType on method reference expr %s", refMethod.getCorrespondingDeclaration().getName());
             if (solveLambdas) {
                 MethodUsage usage = facade.solveMethodAsUsage(callExpr);
                 ResolvedType result = usage.getParamType(pos);