private static String buildAnnotationText(PsiAnnotation annotation) {
   final StringBuilder out = new StringBuilder("@");
   final PsiJavaCodeReferenceElement nameReferenceElement = annotation.getNameReferenceElement();
   assert nameReferenceElement != null;
   out.append(nameReferenceElement.getText());
   final PsiAnnotationParameterList parameterList = annotation.getParameterList();
   final PsiNameValuePair[] attributes = parameterList.getAttributes();
   if (attributes.length == 0) {
     return out.toString();
   }
   out.append('(');
   if (attributes.length == 1) {
     final PsiNameValuePair attribute = attributes[0];
     @NonNls final String name = attribute.getName();
     if (name != null && !PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(name)) {
       out.append(name).append('=');
     }
     buildAttributeValueText(attribute.getValue(), out);
   } else {
     for (int i = 0; i < attributes.length; i++) {
       final PsiNameValuePair attribute = attributes[i];
       if (i > 0) {
         out.append(',');
       }
       out.append(attribute.getName()).append('=');
       buildAttributeValueText(attribute.getValue(), out);
     }
   }
   out.append(')');
   return out.toString();
 }
  @Nullable
  private ProblemDescriptor[] checkMember(
      final PsiDocCommentOwner docCommentOwner,
      final InspectionManager manager,
      final boolean isOnTheFly) {
    final ArrayList<ProblemDescriptor> problems = new ArrayList<ProblemDescriptor>();
    final PsiDocComment docComment = docCommentOwner.getDocComment();
    if (docComment == null) return null;

    final Set<PsiJavaCodeReferenceElement> references = new HashSet<PsiJavaCodeReferenceElement>();
    docComment.accept(getVisitor(references, docCommentOwner, problems, manager, isOnTheFly));
    for (PsiJavaCodeReferenceElement reference : references) {
      final List<PsiClass> classesToImport = new ImportClassFix(reference).getClassesToImport();
      final PsiElement referenceNameElement = reference.getReferenceNameElement();
      problems.add(
          manager.createProblemDescriptor(
              referenceNameElement != null ? referenceNameElement : reference,
              cannotResolveSymbolMessage("<code>" + reference.getText() + "</code>"),
              !isOnTheFly || classesToImport.isEmpty() ? null : new AddImportFix(classesToImport),
              ProblemHighlightType.LIKE_UNKNOWN_SYMBOL,
              isOnTheFly));
    }

    return problems.isEmpty() ? null : problems.toArray(new ProblemDescriptor[problems.size()]);
  }
 @Override
 public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
   super.visitReferenceElement(reference);
   if (referenceFound) {
     return;
   }
   final String text = reference.getText();
   if (text.indexOf((int) '.') >= 0 || !name.equals(text)) {
     return;
   }
   final PsiElement element = reference.resolve();
   if (!(element instanceof PsiClass) || element instanceof PsiTypeParameter) {
     return;
   }
   final PsiClass aClass = (PsiClass) element;
   final String testClassName = aClass.getName();
   final String testClassQualifiedName = aClass.getQualifiedName();
   if (testClassQualifiedName == null
       || testClassName == null
       || testClassQualifiedName.equals(fullyQualifiedName)
       || !testClassName.equals(name)) {
     return;
   }
   referenceFound = true;
 }
 public InspectionGadgetsFix buildFix(Object... infos) {
   final PsiNewExpression expression = (PsiNewExpression) infos[0];
   final PsiJavaCodeReferenceElement classReference = expression.getClassReference();
   assert classReference != null;
   final String className = classReference.getText();
   return new CachedNumberConstructorCallFix(className);
 }
 private static boolean newExpressionsAreEquivalent(
     @NotNull PsiNewExpression newExpression1, @NotNull PsiNewExpression newExpression2) {
   final PsiJavaCodeReferenceElement classReference1 = newExpression1.getClassReference();
   final PsiJavaCodeReferenceElement classReference2 = newExpression2.getClassReference();
   if (classReference1 == null || classReference2 == null) {
     return false;
   }
   final String text = classReference1.getText();
   if (!text.equals(classReference2.getText())) {
     return false;
   }
   final PsiExpression[] arrayDimensions1 = newExpression1.getArrayDimensions();
   final PsiExpression[] arrayDimensions2 = newExpression2.getArrayDimensions();
   if (!expressionListsAreEquivalent(arrayDimensions1, arrayDimensions2)) {
     return false;
   }
   final PsiArrayInitializerExpression arrayInitializer1 = newExpression1.getArrayInitializer();
   final PsiArrayInitializerExpression arrayInitializer2 = newExpression2.getArrayInitializer();
   if (!expressionsAreEquivalent(arrayInitializer1, arrayInitializer2)) {
     return false;
   }
   final PsiExpression qualifier1 = newExpression1.getQualifier();
   final PsiExpression qualifier2 = newExpression2.getQualifier();
   if (!expressionsAreEquivalent(qualifier1, qualifier2)) {
     return false;
   }
   final PsiExpressionList argumentList1 = newExpression1.getArgumentList();
   final PsiExpression[] args1;
   if (argumentList1 == null) {
     args1 = null;
   } else {
     args1 = argumentList1.getExpressions();
   }
   final PsiExpressionList argumentList2 = newExpression2.getArgumentList();
   final PsiExpression[] args2;
   if (argumentList2 == null) {
     args2 = null;
   } else {
     args2 = argumentList2.getExpressions();
   }
   return expressionListsAreEquivalent(args1, args2);
 }
  @Nullable
  static HighlightInfo checkVariableMustBeFinal(
      PsiVariable variable,
      PsiJavaCodeReferenceElement context,
      @NotNull LanguageLevel languageLevel) {
    if (variable.hasModifierProperty(PsiModifier.FINAL)) return null;
    final PsiClass innerClass = getInnerClassVariableReferencedFrom(variable, context);
    if (innerClass != null) {
      if (variable instanceof PsiParameter) {
        final PsiElement parent = variable.getParent();
        if (parent instanceof PsiParameterList
            && parent.getParent() instanceof PsiLambdaExpression
            && notAccessedForWriting(
                variable, new LocalSearchScope(((PsiParameter) variable).getDeclarationScope()))) {
          return null;
        }
      }
      if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)
          && isEffectivelyFinal(variable, innerClass, context)) {
        return null;
      }
      final String description =
          JavaErrorMessages.message("variable.must.be.final", context.getText());

      final HighlightInfo highlightInfo =
          HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
              .range(context)
              .descriptionAndTooltip(description)
              .create();
      QuickFixAction.registerQuickFixAction(
          highlightInfo,
          QUICK_FIX_FACTORY.createVariableAccessFromInnerClassFix(variable, innerClass));
      return highlightInfo;
    }
    final PsiLambdaExpression lambdaExpression =
        PsiTreeUtil.getParentOfType(context, PsiLambdaExpression.class);
    if (lambdaExpression != null && !PsiTreeUtil.isAncestor(lambdaExpression, variable, true)) {
      final PsiElement parent = variable.getParent();
      if (parent instanceof PsiParameterList && parent.getParent() == lambdaExpression) {
        return null;
      }
      if (!isEffectivelyFinal(variable, lambdaExpression, context)) {
        return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
            .range(context)
            .descriptionAndTooltip("Variable used in lambda expression should be effectively final")
            .create();
      }
    }
    return null;
  }
 /**
  * @param strict if strict is true this method checks if the conflicting class which is imported
  *     is actually used in the file. If it isn't the on demand import can be overridden with an
  *     exact import for the fqName without breaking stuff.
  */
 private static boolean hasOnDemandImportConflict(
     @NotNull String fqName, @NotNull PsiJavaFile file, boolean strict) {
   final PsiImportList imports = file.getImportList();
   if (imports == null) {
     return false;
   }
   final PsiImportStatement[] importStatements = imports.getImportStatements();
   final String shortName = ClassUtil.extractClassName(fqName);
   final String packageName = ClassUtil.extractPackageName(fqName);
   for (final PsiImportStatement importStatement : importStatements) {
     if (!importStatement.isOnDemand()) {
       continue;
     }
     final PsiJavaCodeReferenceElement importReference = importStatement.getImportReference();
     if (importReference == null) {
       continue;
     }
     final String packageText = importReference.getText();
     if (packageText.equals(packageName)) {
       continue;
     }
     final PsiElement element = importReference.resolve();
     if (element == null || !(element instanceof PsiPackage)) {
       continue;
     }
     final PsiPackage aPackage = (PsiPackage) element;
     final PsiClass[] classes = aPackage.getClasses();
     for (final PsiClass aClass : classes) {
       final String className = aClass.getName();
       if (!shortName.equals(className)) {
         continue;
       }
       if (!strict) {
         return true;
       }
       final String qualifiedClassName = aClass.getQualifiedName();
       if (qualifiedClassName == null || fqName.equals(qualifiedClassName)) {
         continue;
       }
       return containsReferenceToConflictingClass(file, qualifiedClassName);
     }
   }
   return hasJavaLangImportConflict(fqName, file);
 }
예제 #8
0
  @NotNull
  public static PsiAnnotationMemberValue getMemberValue(
      final PsiElement element, final ClsElementImpl parent) {
    if (element instanceof PsiExpression) {
      return psiToClsExpression((PsiExpression) element, parent);
    } else if (element instanceof PsiArrayInitializerMemberValue) {
      PsiAnnotationMemberValue[] initializers =
          ((PsiArrayInitializerMemberValue) element).getInitializers();
      PsiAnnotationMemberValue[] clsInitializers =
          new PsiAnnotationMemberValue[initializers.length];
      ClsArrayInitializerMemberValueImpl arrayValue =
          new ClsArrayInitializerMemberValueImpl(parent, clsInitializers);
      for (int i = 0; i < initializers.length; i++) {
        clsInitializers[i] = getMemberValue(initializers[i], arrayValue);
      }
      return arrayValue;
    } else if (element instanceof PsiAnnotation) {
      final PsiAnnotation psiAnnotation = (PsiAnnotation) element;
      final PsiJavaCodeReferenceElement referenceElement = psiAnnotation.getNameReferenceElement();
      assert referenceElement != null : psiAnnotation;
      final String canonicalText = referenceElement.getText(); // class file has FQNs
      return new ClsAnnotationValueImpl(parent) {
        @Override
        protected ClsJavaCodeReferenceElementImpl createReference() {
          return new ClsJavaCodeReferenceElementImpl(this, canonicalText);
        }

        @Override
        protected ClsAnnotationParameterListImpl createParameterList() {
          PsiNameValuePair[] psiAttributes = psiAnnotation.getParameterList().getAttributes();
          return new ClsAnnotationParameterListImpl(this, psiAttributes);
        }

        @Override
        public PsiAnnotationOwner getOwner() {
          return (PsiAnnotationOwner) getParent();
        }
      };
    } else {
      LOG.error("Unexpected source element for annotation member value: " + element);
      return null;
    }
  }
예제 #9
0
 @Nullable
 private static PsiImportStaticStatement findOnDemandImportStaticStatement(
     PsiImportList importList, String qualifierClass) {
   final PsiImportStaticStatement[] importStaticStatements =
       importList.getImportStaticStatements();
   for (PsiImportStaticStatement importStaticStatement : importStaticStatements) {
     if (!importStaticStatement.isOnDemand()) {
       continue;
     }
     final PsiJavaCodeReferenceElement importReference =
         importStaticStatement.getImportReference();
     if (importReference == null) {
       continue;
     }
     final String text = importReference.getText();
     if (qualifierClass.equals(text)) {
       return importStaticStatement;
     }
   }
   return null;
 }
  @Nullable
  static HighlightInfo checkVariableMustBeFinal(
      @NotNull PsiVariable variable,
      @NotNull PsiJavaCodeReferenceElement context,
      @NotNull LanguageLevel languageLevel) {
    if (variable.hasModifierProperty(PsiModifier.FINAL)) return null;
    final PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, context);
    if (innerClass instanceof PsiClass) {
      if (variable instanceof PsiParameter) {
        final PsiElement parent = variable.getParent();
        if (parent instanceof PsiParameterList
            && parent.getParent() instanceof PsiLambdaExpression
            && notAccessedForWriting(
                variable, new LocalSearchScope(((PsiParameter) variable).getDeclarationScope()))) {
          return null;
        }
      }
      final boolean isToBeEffectivelyFinal = languageLevel.isAtLeast(LanguageLevel.JDK_1_8);
      if (isToBeEffectivelyFinal && isEffectivelyFinal(variable, innerClass, context)) {
        return null;
      }
      final String description =
          JavaErrorMessages.message(
              isToBeEffectivelyFinal
                  ? "variable.must.be.final.or.effectively.final"
                  : "variable.must.be.final",
              context.getText());

      final HighlightInfo highlightInfo =
          HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
              .range(context)
              .descriptionAndTooltip(description)
              .create();
      QuickFixAction.registerQuickFixAction(
          highlightInfo,
          QUICK_FIX_FACTORY.createVariableAccessFromInnerClassFix(variable, innerClass));
      return highlightInfo;
    }
    return checkWriteToFinalInsideLambda(variable, context);
  }
  @Nullable
  public ProblemDescriptor[] checkFile(
      @NotNull PsiFile file, @NotNull InspectionManager manager, boolean isOnTheFly) {
    // does not work in tests since CodeInsightTestCase copies file into temporary location
    if (ApplicationManager.getApplication().isUnitTestMode()) return null;
    if (file instanceof PsiJavaFile) {
      if (JspPsiUtil.isInJspFile(file)) return null;
      PsiJavaFile javaFile = (PsiJavaFile) file;

      PsiDirectory directory = javaFile.getContainingDirectory();
      if (directory == null) return null;
      PsiPackage dirPackage = JavaDirectoryService.getInstance().getPackage(directory);
      if (dirPackage == null) return null;
      PsiPackageStatement packageStatement = javaFile.getPackageStatement();

      // highlight the first class in the file only
      PsiClass[] classes = javaFile.getClasses();
      if (classes.length == 0 && packageStatement == null) return null;

      String packageName = dirPackage.getQualifiedName();
      if (!Comparing.strEqual(packageName, "", true) && packageStatement == null) {
        String description = JavaErrorMessages.message("missing.package.statement", packageName);

        return new ProblemDescriptor[] {
          manager.createProblemDescriptor(
              classes[0].getNameIdentifier(),
              description,
              new AdjustPackageNameFix(javaFile, null, dirPackage),
              ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
              isOnTheFly)
        };
      }
      if (packageStatement != null) {
        final PsiJavaCodeReferenceElement packageReference = packageStatement.getPackageReference();
        PsiPackage classPackage = (PsiPackage) packageReference.resolve();
        List<LocalQuickFix> availableFixes = new ArrayList<LocalQuickFix>();
        if (classPackage == null) {
          availableFixes.add(new AdjustPackageNameFix(javaFile, packageStatement, dirPackage));
        } else if (!Comparing.equal(
            dirPackage.getQualifiedName(), packageReference.getText(), true)) {
          availableFixes.add(new AdjustPackageNameFix(javaFile, packageStatement, dirPackage));
          MoveToPackageFix moveToPackageFix = new MoveToPackageFix(file, classPackage);
          if (moveToPackageFix.isAvailable()) {
            availableFixes.add(moveToPackageFix);
          }
        }
        if (!availableFixes.isEmpty()) {
          String description =
              JavaErrorMessages.message(
                  "package.name.file.path.mismatch",
                  packageReference.getText(),
                  dirPackage.getQualifiedName());
          return new ProblemDescriptor[] {
            manager.createProblemDescriptor(
                packageStatement.getPackageReference(),
                description,
                isOnTheFly,
                availableFixes.toArray(new LocalQuickFix[availableFixes.size()]),
                ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
          };
        }
      }
    }
    return null;
  }
  @Nullable
  public static HighlightInfo checkApplicability(
      @NotNull PsiAnnotation annotation,
      @NotNull LanguageLevel languageLevel,
      @NotNull PsiFile containingFile) {
    if (ANY_ANNOTATION_ALLOWED.accepts(annotation)) {
      return null;
    }

    PsiJavaCodeReferenceElement nameRef = annotation.getNameReferenceElement();
    if (nameRef == null) return null;

    PsiAnnotationOwner owner = annotation.getOwner();
    PsiAnnotation.TargetType[] targets = PsiImplUtil.getTargetsForLocation(owner);
    if (owner == null || targets.length == 0) {
      String message = JavaErrorMessages.message("annotation.not.allowed.here");
      return annotationError(annotation, message);
    }

    if (!(owner instanceof PsiModifierList)) {
      HighlightInfo info =
          HighlightUtil.checkTypeAnnotationFeature(annotation, languageLevel, containingFile);
      if (info != null) return info;
    }

    PsiAnnotation.TargetType applicable = PsiImplUtil.findApplicableTarget(annotation, targets);
    if (applicable == PsiAnnotation.TargetType.UNKNOWN) return null;

    if (applicable == null) {
      String target = JavaErrorMessages.message("annotation.target." + targets[0]);
      String message =
          JavaErrorMessages.message("annotation.not.applicable", nameRef.getText(), target);
      return annotationError(annotation, message);
    }

    if (applicable == PsiAnnotation.TargetType.TYPE_USE) {
      if (owner instanceof PsiClassReferenceType) {
        PsiJavaCodeReferenceElement ref = ((PsiClassReferenceType) owner).getReference();
        HighlightInfo info = checkReferenceTarget(annotation, ref);
        if (info != null) return info;
      } else if (owner instanceof PsiModifierList) {
        PsiElement nextElement =
            PsiTreeUtil.skipSiblingsForward(
                (PsiModifierList) owner,
                PsiComment.class,
                PsiWhiteSpace.class,
                PsiTypeParameterList.class);
        if (nextElement instanceof PsiTypeElement) {
          PsiTypeElement typeElement = (PsiTypeElement) nextElement;
          PsiType type = typeElement.getType();
          if (PsiType.VOID.equals(type)) {
            String message = JavaErrorMessages.message("annotation.not.allowed.void");
            return annotationError(annotation, message);
          }
          if (!(type instanceof PsiPrimitiveType)) {
            PsiJavaCodeReferenceElement ref =
                getOutermostReferenceElement(typeElement.getInnermostComponentReferenceElement());
            HighlightInfo info = checkReferenceTarget(annotation, ref);
            if (info != null) return info;
          }
        }
      } else if (owner instanceof PsiTypeElement) {
        PsiElement context =
            PsiTreeUtil.skipParentsOfType((PsiTypeElement) owner, PsiTypeElement.class);
        if (context instanceof PsiClassObjectAccessExpression) {
          String message = JavaErrorMessages.message("annotation.not.allowed.class");
          return annotationError(annotation, message);
        }
      }
    }

    return null;
  }
예제 #13
0
  private void generatorLayoutCode(String contextName, String findPre) {
    List<Element> editTextElements = new ArrayList<>();
    List<Element> clickableElements = new ArrayList<>();
    List<Element> itemClickableElements = new ArrayList<>();

    // generator findViewById code in initView() method
    StringBuilder initView = new StringBuilder();
    if (TextUtils.isEmpty(findPre)) {
      initView.append("private void initView() {\n");
    } else {
      initView.append("private void initView(View " + findPre + ") {\n");
    }

    for (Element element : mElements) {
      String pre = TextUtils.isEmpty(findPre) ? "" : findPre + ".";
      initView.append(
          element.getFieldName()
              + " = ("
              + element.name
              + ") "
              + pre
              + "findViewById("
              + element.getFullID()
              + ");\n");

      // set flag
      if (element.isEditText) {
        editTextElements.add(element);
      }
      if (element.isClickable) {
        clickableElements.add(element);
      }
      if (element.isItemClickable) {
        itemClickableElements.add(element);
      }
    }

    // generator EditText validate code if need
    StringBuilder sbEditText = new StringBuilder();
    if (editTextElements.size() > 0) {

      sbEditText.append("private void submit() {\n");
      sbEditText.append("\t\t// validate\n");

      for (Element element : editTextElements) {
        // generator EditText string name
        String idName = element.id;
        int index = idName.lastIndexOf("_");
        String name = index == -1 ? idName : idName.substring(index + 1);
        if (name.equals(idName)) {
          name += "String";
        }

        sbEditText.append("String " + name + " = " + idName + ".getText().toString().trim();\n");
        sbEditText.append("if(TextUtils.isEmpty(" + name + ")) {\n");
        // 提示的toast为EditText的hint文字,无hint时格式为"name不能为空"
        String emptyTint = name + "不能为空";
        String hint = element.xml.getAttributeValue("android:hint");
        if (!TextUtils.isEmpty(hint) && !hint.startsWith("@string")) {
          emptyTint = hint;
        }
        sbEditText.append(
            "Toast.makeText("
                + contextName
                + ", \""
                + emptyTint
                + "\", Toast.LENGTH_SHORT).show();\n");
        sbEditText.append("return;\n");
        sbEditText.append("}\n");
        sbEditText.append("\n");
      }

      sbEditText.append("\t\t// TODO validate success, do something\n");
      sbEditText.append("\n\n}\n");
    }

    // generator clickable code if need
    StringBuilder sbClickable = new StringBuilder();
    if (clickableElements.size() > 0) {
      // let class implement OnClickListener
      PsiReferenceList implementsList = mClass.getImplementsList();
      if (implementsList != null) {
        PsiJavaCodeReferenceElement[] referenceElements = implementsList.getReferenceElements();
        boolean hasImpl = false;
        for (PsiJavaCodeReferenceElement re : referenceElements) {
          hasImpl = re.getText().contains("OnClickListener");
        }
        // add implement if not exist
        if (!hasImpl) {
          PsiJavaCodeReferenceElement pjcre =
              mFactory.createReferenceElementByFQClassName(
                  "android.view.View.OnClickListener", mClass.getResolveScope());
          implementsList.add(pjcre);
        }
      }

      initView.append("\n");

      sbClickable
          .append("@Override public void onClick(View v) {\n")
          .append("switch (v.getId()) {\n");

      for (Element element : clickableElements) {
        // generator setOnClickListener code in initView()
        initView.append(element.getFieldName() + ".setOnClickListener(this);\n");

        // generator override public void onClick(View v) method
        sbClickable.append("case " + element.getFullID() + " :\n\nbreak;\n");
      }
      sbClickable.append("}\n}");
    }

    // generator itemClickable code if need
    for (Element element : itemClickableElements) {
      // generator setOnClickListener code in initView()
      initView.append(
          element.getFieldName()
              + ".setOnItemClickListener(new AdapterView.OnItemClickListener() {\n");
      initView.append("@Override\n");
      initView.append(
          "public void onItemClick(AdapterView<?> parent, View view, int position, long id) {\n\n");
      initView.append("}\n");
      initView.append("});\n");
    }

    initView.append("}\n");

    PsiMethod[] initViewMethods = mClass.findMethodsByName("initView", false);
    if (initViewMethods.length > 0 && initViewMethods[0].getBody() != null) {
      // already have method
      // append non-repeated field
      PsiCodeBlock initViewMethodBody = initViewMethods[0].getBody();

      for (Element element : mElements) {

        // append findViewById
        String pre = TextUtils.isEmpty(findPre) ? "" : findPre + ".";
        String s2 =
            element.getFieldName()
                + " = ("
                + element.name
                + ") "
                + pre
                + "findViewById("
                + element.getFullID()
                + ");";
        initViewMethodBody.add(mFactory.createStatementFromText(s2, initViewMethods[0]));

        // append setOnClickListener
        String s1 = element.getFieldName() + ".setOnClickListener(this);";
        initViewMethodBody.add(mFactory.createStatementFromText(s1, initViewMethods[0]));
      }
    } else {
      // new method
      mClass.add(mFactory.createMethodFromText(initView.toString(), mClass));
    }

    if (clickableElements.size() > 0) {
      PsiMethod[] onClickMethods = mClass.findMethodsByName("onClick", false);
      if (onClickMethods.length > 0 && onClickMethods[0].getBody() != null) {
        // already have method
        // append non-repeated field
        PsiCodeBlock onClickMethodBody = onClickMethods[0].getBody();

        for (PsiElement element : onClickMethodBody.getChildren()) {
          if (element instanceof PsiSwitchStatement) {
            PsiSwitchStatement switchStatement = (PsiSwitchStatement) element;
            PsiCodeBlock body = switchStatement.getBody();
            if (body != null) {
              for (Element clickableElement : clickableElements) {
                String caseStr = "case " + clickableElement.getFullID() + " :";
                body.add(mFactory.createStatementFromText(caseStr, body));
                body.add(mFactory.createStatementFromText("break;", body));
              }
            }
            break;
          }
        }
      } else {
        // new method
        mClass.add(mFactory.createMethodFromText(sbClickable.toString(), mClass));
      }
    }

    if (editTextElements.size() > 0) {
      mClass.add(mFactory.createMethodFromText(sbEditText.toString(), mClass));
    }
  }