@Override
  public boolean prepareSymptom(Symptom symptom) throws RefactoringException {
    loadEnvironment();
    //        reloadEnv();

    PullPushMethodSymptom pullPushMethodSymptom = (PullPushMethodSymptom) symptom;

    currentTarget =
        getProject()
            .getTypeRefForSourceName(pullPushMethodSymptom.getTargetQualifiedName())
            .getBinCIType();
    BinCIType owner =
        getProject()
            .getTypeRefForSourceName(pullPushMethodSymptom.getParentQualifiedName())
            .getBinCIType();

    BinMember member =
        owner.getDeclaredMethod(
            pullPushMethodSymptom.getMemberName(), pullPushMethodSymptom.getBinParameters());
    if (member == null) {
      member =
          getMethodManually(
              pullPushMethodSymptom.getMemberName(),
              owner,
              pullPushMethodSymptom.getBinParameters());
    }
    currentMethod = (BinMethod) member;

    return reloadRefactoring();
  }
  public void test() {
    String qName = "Test2";

    BinTypeRef ref = project.getTypeRefForName(qName);
    assertNotNull(ref);
    BinCIType type = ref.getBinCIType();

    BinMethod[] methods = type.getDeclaredMethods();
    for (int i = 0; i < methods.length; i++) {

      if (methods[i].getName().equals("main")) {
        MethodVisitor visitor = new MethodVisitor();
        methods[i].accept(visitor);

        for (int j = 0; j < visitor.METHODS.size(); j++) {

          if (((String) visitor.METHODS.get(j)).equals("target2")) {
            String retType = (String) visitor.RETTYPES.get(j);

            //            System.out.println(retType);

            assertTrue("Return type must be String, found: " + retType, retType.equals("String"));
          } else if (((String) visitor.METHODS.get(j)).equals("target")) {
            String retType = (String) visitor.RETTYPES.get(j);

            //            System.out.println(retType);

            assertTrue("Return type must be Integer, found: " + retType, retType.equals("Integer"));
          }
        }
      }
    }
  }
Exemplo n.º 3
0
  private void findFolders(String prefix, BinPackage aPackage, Set result) {
    for (Iterator i = aPackage.getAllTypes(); i.hasNext(); ) {
      BinCIType type = ((BinTypeRef) i.next()).getBinCIType();

      Source folder = findFolder(prefix, type);
      if (folder != null) {
        result.add(folder);
      } else {
        getSourcesInWrongFolders().add(type.getCompilationUnit().getSource());
      }
    }
  }
Exemplo n.º 4
0
  /**
   * Creates a method with a body for the getter.
   *
   * @return getter body
   */
  private String createGetterBody() {
    // TODO: use access modifier given by user

    int modifier = this.getGetterVisibility();
    if (field.isStatic()) {
      modifier |= BinModifier.STATIC;
    }
    BinMethod getter =
        new BinMethod(
            getterName,
            BinParameter.NO_PARAMS,
            getField().getTypeRef(),
            modifier,
            BinMethod.Throws.NO_THROWS);
    getter.setOwner(field.getOwner());

    BinMethodFormatter formatter = (BinMethodFormatter) getter.getFormatter();
    String result = FormatSettings.LINEBREAK + formatter.formHeader();

    // TODO migrate to formatting engine also?
    int baseIndent = new BinTypeFormatter(field.getOwner().getBinCIType()).getMemberIndent();
    result += FormatSettings.getIndentString(baseIndent + FormatSettings.getBlockIndent());
    result += "return ";
    if (field.isStatic()) {
      result += hostingClass.getName();
    } else {
      result += "this";
    }
    result += "." + getField().getName() + ";";
    result += FormatSettings.LINEBREAK;

    result += formatter.formFooter();

    return result;
  }
Exemplo n.º 5
0
  private Source findFolder(String prefix, BinCIType type) {
    CompilationUnit compilationUnit = type.getCompilationUnit();
    if (compilationUnit == null) {
      return null;
    }

    return findParent(prefix, compilationUnit.getSource());
  }
Exemplo n.º 6
0
  /**
   * Checks whether a to-be-created accessor doesn't conflict with the current classmodel.
   *
   * @param method virtual to-be-created accessor
   * @param errors list of error messages that is populated
   */
  private void checkVirtualAccessor(BinMethod method, List errors) {
    for (final Iterator i = hostingClass.getTypeRef().getAllSubclasses().iterator();
        i.hasNext(); ) {
      BinCIType subtype = ((BinTypeRef) i.next()).getBinCIType();
      BinMethod[] methods = subtype.getDeclaredMethods();
      for (int pos = 0, max = methods.length; pos < max; pos++) {
        BinMethod current = methods[pos];

        // FIXME: or vice-versa: method.isApplicable(current)?
        if (current.isApplicable(method)
            && method.isAccessible(hostingClass, subtype)
            && !current.isAbstract()) {
          CollectionUtil.addNew(errors, "Conflicts with the existing method '" + current + "'");
        }
      } // end for methods
    } // end for subtypes

    for (final Iterator i = hostingClass.getTypeRef().getAllSupertypes().iterator();
        i.hasNext(); ) {
      BinCIType supertype = ((BinTypeRef) i.next()).getBinCIType();
      BinMethod[] methods = supertype.getDeclaredMethods();
      for (int pos = 0, max = methods.length; pos < max; pos++) {
        BinMethod current = methods[pos];

        // FIXME: or vice-versa: method.isApplicable(current)?
        if (current.isApplicable(method)
            && current.isAccessible(supertype, hostingClass)
            && !current.isAbstract()) {
          CollectionUtil.addNew(errors, "Conflicts with the existing method '" + current + "'");
        }
      } // end for methods
    }
  }
Exemplo n.º 7
0
  @Override
  public List<Symptom> findAllSymptoms() throws RefactoringException {
    if (!loadEnvironment()) {
      return null;
    }

    List<Symptom> result = new ArrayList<Symptom>();

    for (Object object : getProject().getDefinedTypes()) {
      BinCITypeRef binCITypeRef = (BinCITypeRef) object;
      BinCIType bcitr = binCITypeRef.getBinCIType();

      if (bcitr.isInterface()) {
        continue;
      }

      if (bcitr.isInnerType() && !bcitr.isStatic()) {
        continue;
      }

      if (bcitr.isAbstract()) {
        continue;
      }

      if (!classShouldBeVerified(binCITypeRef)) {
        continue;
      }

      BinClass cls = (BinClass) bcitr;
      BinConstructor[] constructors = cls.getConstructors();
      for (BinConstructor binConstructor : constructors) {
        Symptom symptom = new CreateFactoryMethodSymptom(binConstructor, this);
        result.add(symptom);
      }
    }
    return result;
  }
Exemplo n.º 8
0
 /** @return setter for curent encapsulation, null if not present */
 private BinMethod getSetterMethod() {
   return hostingClass.getDeclaredMethod(
       setterName, new BinParameter[] {new BinParameter(field.getName(), field.getTypeRef(), 0)});
 }
Exemplo n.º 9
0
 /** @return getter for curent encapsulation, null if not present */
 private BinMethod getGetterMethod() {
   return hostingClass.getDeclaredMethod(getterName, BinTypeRef.NO_TYPEREFS);
 }