1 files changed, 153 insertions, 0 deletions
diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/confusing/ClashingTraitMethodsInspectionBase.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/confusing/ClashingTraitMethodsInspectionBase.java
new file mode 100644
index 000000000000..4195dd9a11ae
--- /dev/null
+++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/confusing/ClashingTraitMethodsInspectionBase.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jetbrains.plugins.groovy.codeInspection.confusing;
+
+import com.intellij.codeInspection.LocalQuickFix;
+import com.intellij.codeInspection.ProblemHighlightType;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Condition;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.HierarchicalMethodSignature;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.PsiModifier;
+import com.intellij.psi.util.PsiFormatUtil;
+import com.intellij.psi.util.PsiFormatUtilBase;
+import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.groovy.codeInspection.BaseInspection;
+import org.jetbrains.plugins.groovy.codeInspection.BaseInspectionVisitor;
+import org.jetbrains.plugins.groovy.codeInspection.GroovyFix;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
+import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrTraitMethod;
+import org.jetbrains.plugins.groovy.lang.psi.util.GrTraitUtil;
+
+import java.util.Collection;
+import java.util.List;
+
+public abstract class ClashingTraitMethodsInspectionBase extends BaseInspection {
+  protected static final Logger LOG = Logger.getInstance(ClashingTraitMethodsInspectionBase.class);
+
+  @NotNull
+  protected static List<ClashingMethod> collectClassingMethods(@NotNull GrTypeDefinition typeDefinition) {
+    Collection<HierarchicalMethodSignature> visibleSignatures = typeDefinition.getVisibleSignatures();
+
+    List<ClashingMethod> clashingMethods = ContainerUtil.newArrayList();
+    for (HierarchicalMethodSignature signature : visibleSignatures) {
+      PsiMethod method = signature.getMethod();
+      if (method instanceof GrTraitMethod && method.getContainingClass() == typeDefinition) {
+        List<HierarchicalMethodSignature> superSignatures = signature.getSuperSignatures();
+        if (superSignatures.size() > 1) {
+          List<GrTypeDefinition> traits = ContainerUtil.newArrayList();
+          for (HierarchicalMethodSignature superSignature : superSignatures) {
+            PsiMethod superMethod = superSignature.getMethod();
+            PsiClass superClass = superMethod.getContainingClass();
+            if (GrTraitUtil.isTrait(superClass) &&
+                !superMethod.getModifierList().hasExplicitModifier(PsiModifier.ABSTRACT)) {
+              traits.add((GrTypeDefinition)superClass);
+            }
+          }
+
+          if (traits.size() > 1) {
+            clashingMethods.add(new ClashingMethod(signature, traits));
+          }
+        }
+      }
+    }
+
+    return clashingMethods;
+  }
+
+  @NotNull
+  private static List<PsiClass> collectImplementedTraits(@NotNull GrTypeDefinition typeDefinition) {
+    return ContainerUtil.findAll(typeDefinition.getSupers(), new Condition<PsiClass>() {
+      @Override
+      public boolean value(PsiClass aClass) {
+        return GrTraitUtil.isTrait(aClass);
+      }
+    });
+  }
+
+  @NotNull
+  @Override
+  protected BaseInspectionVisitor buildVisitor() {
+    return new BaseInspectionVisitor() {
+      @Override
+      public void visitTypeDefinition(GrTypeDefinition typeDefinition) {
+        super.visitTypeDefinition(typeDefinition);
+
+        List<PsiClass> superTraits = collectImplementedTraits(typeDefinition);
+
+        if (superTraits.size() < 2) return;
+
+        List<ClashingMethod> clashingMethods = collectClassingMethods(typeDefinition);
+
+        for (ClashingMethod clashing : clashingMethods) {
+          registerError(typeDefinition.getNameIdentifierGroovy(), buildWarning(clashing), new LocalQuickFix[]{getFix()}, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
+        }
+      }
+
+      @NotNull
+      private String buildWarning(@NotNull ClashingMethod entry) {
+        return "Traits " + buildTraitString(entry) + " contain clashing methods with signature " + buildSignatureString(entry);
+      }
+
+      @NotNull
+      private String buildSignatureString(@NotNull ClashingMethod entry) {
+        HierarchicalMethodSignature signature = entry.getSignature();
+        return PsiFormatUtil.formatMethod(signature.getMethod(), signature.getSubstitutor(),
+                                          PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS,
+                                          PsiFormatUtilBase.SHOW_TYPE);
+      }
+
+      @NotNull
+      private String buildTraitString(@NotNull ClashingMethod entry) {
+        return StringUtil.join(entry.getSuperTraits(), new Function<GrTypeDefinition, String>() {
+          @Override
+          public String fun(GrTypeDefinition tr) {
+            return tr.getName();
+          }
+        }, ", ");
+      }
+    };
+  }
+
+  @NotNull
+  protected LocalQuickFix getFix(){
+    return GroovyFix.EMPTY_FIX;
+  }
+
+  protected static class ClashingMethod {
+    private final HierarchicalMethodSignature mySignature;
+    private final List<GrTypeDefinition> mySuperTraits;
+
+    public ClashingMethod(@NotNull HierarchicalMethodSignature signature, @NotNull List<GrTypeDefinition> superTraits) {
+      mySignature = signature;
+      mySuperTraits = superTraits;
+    }
+
+    @NotNull
+    public HierarchicalMethodSignature getSignature() {
+      return mySignature;
+    }
+
+    @NotNull
+    public List<GrTypeDefinition> getSuperTraits() {
+      return mySuperTraits;
+    }
+  }
+}