You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2018/03/17 16:10:22 UTC

groovy git commit: Minor refactoring for `syntheticPublic` determination

Repository: groovy
Updated Branches:
  refs/heads/master 4ba0b72b2 -> 754688322


Minor refactoring for `syntheticPublic` determination


Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/75468832
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/75468832
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/75468832

Branch: refs/heads/master
Commit: 7546883220e7839cb4daf7fd0ac5e58b3aa2064c
Parents: 4ba0b72
Author: danielsun1106 <re...@hotmail.com>
Authored: Sun Mar 18 00:10:16 2018 +0800
Committer: danielsun1106 <re...@hotmail.com>
Committed: Sun Mar 18 00:10:16 2018 +0800

----------------------------------------------------------------------
 .../apache/groovy/parser/antlr4/AstBuilder.java | 51 ++++----------------
 .../groovy/parser/antlr4/ModifierManager.java   | 21 ++++++--
 2 files changed, 26 insertions(+), 46 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/groovy/blob/75468832/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index 5af6995..f7f182d 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -1271,7 +1271,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
                 .filter(Objects::nonNull).reduce(new LinkedList<MethodDeclarationContext>(), (r, e) -> {
                     MethodDeclarationContext methodDeclarationContext = (MethodDeclarationContext) e;
 
-                    if (createModifierManager(methodDeclarationContext).contains(DEFAULT)) {
+                    if (createModifierManager(methodDeclarationContext).containsAny(DEFAULT)) {
                         ((List) r).add(methodDeclarationContext);
                     }
 
@@ -1551,7 +1551,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
 
         ModifierManager modifierManager = createModifierManager(ctx);
 
-        if (modifierManager.contains(VAR)) {
+        if (modifierManager.containsAny(VAR)) {
             throw createParsingFailedException("var cannot be used for method declarations", ctx);
         }
 
@@ -1584,7 +1584,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
                         asBoolean(ctx.returnType()),
                         modifierManager));
 
-        if (modifierManager.contains(STATIC)) {
+        if (modifierManager.containsAny(STATIC)) {
             for (Parameter parameter : methodNode.getParameters()) {
                 parameter.setInStaticContext(true);
             }
@@ -1635,7 +1635,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
             }
 
             boolean isInterfaceOrAbstractClass = asBoolean(classNode) && classNode.isAbstract() && !classNode.isAnnotationDefinition();
-            if (isInterfaceOrAbstractClass && !modifierManager.contains(DEFAULT) && isAbstractMethod && hasMethodBody) {
+            if (isInterfaceOrAbstractClass && !modifierManager.containsAny(DEFAULT) && isAbstractMethod && hasMethodBody) {
                 throw createParsingFailedException("You defined an abstract method[" + methodNode.getName() + "] with body. Try removing the method body" + (classNode.isInterface() ? ", or declare it default" : ""), methodNode);
             }
         }
@@ -1652,7 +1652,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
         methodNode =
                 new MethodNode(
                         methodName,
-                        modifierManager.contains(PRIVATE) ? Opcodes.ACC_PRIVATE : Opcodes.ACC_PUBLIC,
+                        modifierManager.containsAny(PRIVATE) ? Opcodes.ACC_PRIVATE : Opcodes.ACC_PUBLIC,
                         returnType,
                         parameters,
                         exceptions,
@@ -1697,7 +1697,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
 
         }
 
-        modifiers |= !modifierManager.contains(STATIC) && (classNode.isInterface() || (isTrue(classNode, IS_INTERFACE_WITH_DEFAULT_METHODS) && !modifierManager.contains(DEFAULT))) ? Opcodes.ACC_ABSTRACT : 0;
+        modifiers |= !modifierManager.containsAny(STATIC) && (classNode.isInterface() || (isTrue(classNode, IS_INTERFACE_WITH_DEFAULT_METHODS) && !modifierManager.containsAny(DEFAULT))) ? Opcodes.ACC_ABSTRACT : 0;
 
         checkWhetherMethodNodeWithSameSignatureExists(classNode, methodName, parameters, ctx);
 
@@ -4400,38 +4400,8 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
             boolean isAnnotationDeclaration,
             boolean isAnonymousInnerEnumDeclaration,
             boolean hasReturnType,
-            ModifierManager modifierManager
-    ) {
-        return this.isSyntheticPublic(
-                isAnnotationDeclaration,
-                isAnonymousInnerEnumDeclaration,
-                modifierManager.containsAnnotations(),
-                modifierManager.containsVisibilityModifier(),
-                modifierManager.containsNonVisibilityModifier(),
-                hasReturnType,
-                modifierManager.contains(DEF) || modifierManager.contains(VAR));
-    }
-
-    /**
-     * @param isAnnotationDeclaration         whether the method is defined in an annotation
-     * @param isAnonymousInnerEnumDeclaration whether the method is defined in an anonymous inner enum
-     * @param hasAnnotation                   whether the method declaration has annotations
-     * @param hasVisibilityModifier           whether the method declaration contains visibility modifier(e.g. public, protected, private)
-     * @param hasModifier                     whether the method declaration has modifier(e.g. visibility modifier, final, static and so on)
-     * @param hasReturnType                   whether the method declaration has an return type(e.g. String, generic types)
-     * @param hasDef                          whether the method declaration using def keyword
-     * @return the result
-     */
-    private boolean isSyntheticPublic(
-            boolean isAnnotationDeclaration,
-            boolean isAnonymousInnerEnumDeclaration,
-            boolean hasAnnotation,
-            boolean hasVisibilityModifier,
-            boolean hasModifier,
-            boolean hasReturnType,
-            boolean hasDef) {
-
-        if (hasVisibilityModifier) {
+            ModifierManager modifierManager) {
+        if (modifierManager.containsVisibilityModifier()) {
             return false;
         }
 
@@ -4439,16 +4409,15 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
             return true;
         }
 
-        if (hasDef && hasReturnType) {
+        if (hasReturnType && (modifierManager.containsAny(DEF, VAR))) {
             return true;
         }
 
-        if (hasModifier || hasAnnotation || !hasReturnType) {
+        if (!hasReturnType || modifierManager.containsNonVisibilityModifier() || modifierManager.containsAnnotations()) {
             return true;
         }
 
         return isAnonymousInnerEnumDeclaration;
-
     }
 
     // the mixins of interface and annotation should be null

http://git-wip-us.apache.org/repos/asf/groovy/blob/75468832/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
index 808a416..286adfe 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
@@ -35,8 +35,11 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
-import static org.apache.groovy.parser.antlr4.GroovyParser.*;
-import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean;
+import static org.apache.groovy.parser.antlr4.GroovyLangParser.ABSTRACT;
+import static org.apache.groovy.parser.antlr4.GroovyLangParser.FINAL;
+import static org.apache.groovy.parser.antlr4.GroovyLangParser.NATIVE;
+import static org.apache.groovy.parser.antlr4.GroovyLangParser.STATIC;
+import static org.apache.groovy.parser.antlr4.GroovyLangParser.VOLATILE;
 
 /**
  * Process modifiers for AST nodes
@@ -54,7 +57,7 @@ class ModifierManager {
     public ModifierManager(AstBuilder astBuilder, List<ModifierNode> modifierNodeList) {
         this.astBuilder = astBuilder;
         this.validate(modifierNodeList);
-        this.modifierNodeList = Collections.unmodifiableList(asBoolean((Object) modifierNodeList) ? modifierNodeList : Collections.emptyList());
+        this.modifierNodeList = Collections.unmodifiableList(modifierNodeList);
     }
 
     public int getModifierCount() {
@@ -134,8 +137,16 @@ class ModifierManager {
                 .collect(Collectors.toList());
     }
 
-    public boolean contains(int modifierType) {
-        return modifierNodeList.stream().anyMatch(e -> modifierType == e.getType());
+    public boolean containsAny(final int... modifierTypes) {
+        return modifierNodeList.stream().anyMatch(e -> {
+            for (int modifierType : modifierTypes) {
+                if (modifierType == e.getType()) {
+                    return true;
+                }
+            }
+
+            return false;
+        });
     }
 
     public Optional<ModifierNode> get(int modifierType) {