/**
  * Replaces the element by an statement list containing all unary operators in the element
  *
  * @param element
  */
 private void replaceByUnaryBlock(CtElement element) {
   CtBlock<CtUnaryOperator> opBlock = new CtBlockImpl<CtUnaryOperator>();
   for (CtUnaryOperator s :
       element.getElements(new TypeFilter<CtUnaryOperator>(CtUnaryOperator.class)))
     if (s.getKind().compareTo(UnaryOperatorKind.PREINC) >= 0) {
       s.setParent(null);
       opBlock.addStatement(s);
       s.setParent(opBlock);
     }
   element.replace(opBlock);
 }
示例#2
0
 private void replace(CtElement e, CtElement op) {
   if (e instanceof CtStatement && op instanceof CtStatement) {
     ((CtStatement) e).replace((CtStatement) op);
     return;
   }
   if (e instanceof CtExpression && op instanceof CtExpression) {
     ((CtExpression) e).replace((CtExpression) op);
     return;
   }
   throw new IllegalArgumentException(e.getClass() + " " + op.getClass());
 }
示例#3
0
 private <T extends FactoryAccessor> T getReplacement(T replacement, Object parent) {
   // T ret = replacement.getFactory().Core().clone(replacement);
   if (replacement instanceof CtElement && parent instanceof CtElement) {
     ((CtElement) replacement).setParent((CtElement) parent);
   }
   return replacement;
 }
示例#4
0
 @Override
 public void scan(final CtElement element) {
   if (element != null && clazz.isAssignableFrom(element.getClass())) {
     final T potentialVariable = (T) element;
     if (name.equals(potentialVariable.getSimpleName())) {
       // Since the AST is not completely available yet, we can not check if element's
       // parent (ep) contains the innermost element of `stack` (ie). Therefore, we
       // have to check if one of the following condition holds:
       //
       //    1) Does `stack` contain `ep`?
       //    2) Is `ep` the body of one of `stack`'s CtExecutable elements?
       //
       // The first condition is easy to see. If `stack` contains `ep` then `ep` and
       // all it's declared variables are in scope of `ie`. Unfortunately, there is a
       // special case in which a variable (a CtLocalVariable) has been declared in a
       // block (CtBlock) of, for instance, a method. Such a block is not contained in
       // `stack`. This peculiarity calls for the second condition.
       final CtElement parentOfPotentialVariable = potentialVariable.getParent();
       for (final ASTPair astPair : stack) {
         if (astPair.element == parentOfPotentialVariable) {
           finish(potentialVariable);
           return;
         } else if (astPair.element instanceof CtExecutable) {
           final CtExecutable executable = (CtExecutable) astPair.element;
           if (executable.getBody() == parentOfPotentialVariable) {
             finish(potentialVariable);
             return;
           }
         }
       }
     }
   }
   super.scan(element);
 }
示例#5
0
 public int compareTo(CtElement o) {
   String current = getSignature();
   String other = o.getSignature();
   if (current.length() <= 0 || other.length() <= 0) {
     throw new ClassCastException("Unable to compare elements");
   }
   return current.compareTo(other);
 }
 @Override()
 public void report(Processor processor, Severity severity, CtElement element, String message) {
   String msg =
       processor.getClass().getSimpleName()
           + ">>"
           + element.getPosition().getFile()
           + "@["
           + element.getPosition().getLine()
           + ","
           + element.getPosition().getColumn()
           + "]:"
           + message;
   if (Severity.ERROR.equals(severity)) {
     logger_.error(msg);
   } else if (Severity.WARNING.equals(severity)) {
     logger_.warn(msg);
   } else {
     logger_.info(msg);
   }
 }
 /**
  * Indicates that contains operation assignment over variables non local to the element
  *
  * @param element
  * @return
  */
 private boolean containNonLocalOperatorAssignment(CtElement element) {
   // Handling operators assignment
   for (CtOperatorAssignment op :
       element.getElements(new TypeFilter<CtOperatorAssignment>(CtOperatorAssignment.class))) {
     for (CtVariableAccess a : accessOfExpression(op.getAssigned())) {
       // Add cyclic dependencies
       if (!declaredInsideBlock.contains(a.getVariable())) return true;
     }
   }
   return false;
 }
 /**
  * Indicates if the element contains unary operators acting on variables declared outside the
  * block being degraded
  *
  * @param element Element to inspect
  * @return True if contains
  */
 private boolean containsNonLocalUnaryOperators(CtElement element) {
   // Handling unary operators
   for (CtUnaryOperator op :
       element.getElements(new TypeFilter<CtUnaryOperator>(CtUnaryOperator.class))) {
     for (CtVariableAccess a : accessOfExpression(op)) {
       // We don't care about cyclic dependencies to vars declared inside the block being degraded
       if (!declaredInsideBlock.contains(a.getVariable())) return true;
     }
   }
   return false;
 }
示例#9
0
  /**
   * Dans cette méthode on vérifie si la classe/méthode de l'élément analysé correspondent et si la
   * vérification particulière correspond.On retourne le résultat sou forme de boolean
   *
   * @param candidate l'élément analysé
   * @return résultat de la vérification
   */
  @Override
  public boolean isToBeProcessed(CtElement candidate) {
    CtPackage p = candidate.getParent(CtPackage.class);
    CtClass c = candidate.getParent(CtClass.class);
    CtMethod m = candidate.getParent(CtMethod.class);
    try {
      if (pecularVerify(candidate)) {
        if (verifyPackage(p.getSimpleName())) {
          if (verifyClass(c.getSimpleName())) {
            if (verifyMethod(m.getSignature())) {
              return verifyNbApplication();
            }
          }
        }
      }

    } catch (NullPointerException e) {
      return false;
    }
    return false;
  }
示例#10
0
  @SuppressWarnings("unchecked")
  void enter(CtElement e, ASTNode node) {
    stack.push(new ASTPair(e, node));
    if (!(e instanceof CtPackage)
        || (compilationUnitSpoon.getFile() != null
            && compilationUnitSpoon
                .getFile()
                .getName()
                .equals(DefaultJavaPrettyPrinter.JAVA_PACKAGE_DECLARATION))) {
      if (compilationunitdeclaration != null) {
        e.setPosition(this.jdtTreeBuilder.getPositionBuilder().buildPositionCtElement(e, node));
      }
    }

    ASTPair pair = stack.peek();
    CtElement current = pair.element;

    if (current instanceof CtExpression) {
      while (!casts.isEmpty()) {
        ((CtExpression<?>) current).addTypeCast(casts.remove(0));
      }
    }
    if (current instanceof CtStatement && !this.label.isEmpty()) {
      ((CtStatement) current).setLabel(this.label.pop());
    }

    try {
      if (e instanceof CtTypedElement
          && !(e instanceof CtConstructorCall)
          && node instanceof Expression) {
        if (((CtTypedElement<?>) e).getType() == null) {
          ((CtTypedElement<Object>) e)
              .setType(
                  this.jdtTreeBuilder
                      .getReferencesBuilder()
                      .getTypeReference(((Expression) node).resolvedType));
        }
      }
    } catch (UnsupportedOperationException ignore) {
      // For some element, we throw an UnsupportedOperationException when we call setType().
    }
  }