public static void getInvalidQualificationProposals(
      IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
    ASTNode node = problem.getCoveringNode(context.getASTRoot());
    if (!(node instanceof Name)) {
      return;
    }
    Name name = (Name) node;
    IBinding binding = name.resolveBinding();
    if (!(binding instanceof ITypeBinding)) {
      return;
    }
    ITypeBinding typeBinding = (ITypeBinding) binding;

    AST ast = node.getAST();
    ASTRewrite rewrite = ASTRewrite.create(ast);
    rewrite.replace(name, ast.newName(typeBinding.getQualifiedName()), null);

    String label = CorrectionMessages.JavadocTagsSubProcessor_qualifylinktoinner_description;
    Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
    ASTRewriteCorrectionProposal proposal =
        new ASTRewriteCorrectionProposal(
            label,
            context.getCompilationUnit(),
            rewrite,
            IProposalRelevance.QUALIFY_INNER_TYPE_NAME,
            image);

    proposals.add(proposal);
  }
 /*
  * @see ASTVisitor#visit(MethodDeclaration)
  */
 public boolean visit(MethodDeclaration node) {
   if (node.getJavadoc() != null) {
     node.getJavadoc().accept(this);
   }
   if (node.getAST().apiLevel() >= AST.JLS3) {
     printModifiers(node.modifiers());
     if (!node.typeParameters().isEmpty()) {
       this.fBuffer.append("<"); // $NON-NLS-1$
       for (Iterator it = node.typeParameters().iterator(); it.hasNext(); ) {
         TypeParameter t = (TypeParameter) it.next();
         t.accept(this);
         if (it.hasNext()) {
           this.fBuffer.append(", "); // $NON-NLS-1$
         }
       }
       this.fBuffer.append("> "); // $NON-NLS-1$
     }
   }
   if (!node.isConstructor()) {
     if (node.getReturnType2() != null) {
       node.getReturnType2().accept(this);
     } else {
       // methods really ought to have a return type
       this.fBuffer.append("void"); // $NON-NLS-1$
     }
     this.fBuffer.append(" "); // $NON-NLS-1$
   }
   node.getName().accept(this);
   this.fBuffer.append("("); // $NON-NLS-1$
   for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
     SingleVariableDeclaration v = (SingleVariableDeclaration) it.next();
     v.accept(this);
     if (it.hasNext()) {
       this.fBuffer.append(", "); // $NON-NLS-1$
     }
   }
   this.fBuffer.append(")"); // $NON-NLS-1$
   for (int i = 0; i < node.getExtraDimensions(); i++) {
     this.fBuffer.append("[]"); // $NON-NLS-1$
   }
   if (!node.thrownExceptions().isEmpty()) {
     this.fBuffer.append(" throws "); // $NON-NLS-1$
     for (Iterator it = node.thrownExceptions().iterator(); it.hasNext(); ) {
       Name n = (Name) it.next();
       n.accept(this);
       if (it.hasNext()) {
         this.fBuffer.append(", "); // $NON-NLS-1$
       }
     }
     this.fBuffer.append(" "); // $NON-NLS-1$
   }
   if (node.getBody() == null) {
     this.fBuffer.append(";"); // $NON-NLS-1$
   } else {
     node.getBody().accept(this);
   }
   return false;
 }
예제 #3
0
  private static VariableDeclaration getVariableDeclaration(Name node) {
    IBinding binding = node.resolveBinding();
    if (binding == null && node.getParent() instanceof VariableDeclaration)
      return (VariableDeclaration) node.getParent();

    if (binding != null && binding.getKind() == IBinding.VARIABLE) {
      CompilationUnit cu = (CompilationUnit) ASTNodes.getParent(node, CompilationUnit.class);
      return ASTNodes.findVariableDeclaration(((IVariableBinding) binding), cu);
    }
    return null;
  }
 private void possibleTypeRefFound(Name node) {
   while (node.isQualifiedName()) {
     node = ((QualifiedName) node).getQualifier();
   }
   IBinding binding = node.resolveBinding();
   if (binding == null || binding.getKind() == IBinding.TYPE) {
     // if the binding is null, we cannot determine if
     // we have a type binding or not, so we will assume
     // we do.
     addReference((SimpleName) node);
   }
 }
예제 #5
0
  @Override
  protected void visitName(Name node) {
    IBinding binding = node.resolveBinding();

    if (binding instanceof IVariableBinding && !((IVariableBinding) binding).isField()) {
      if (knownVariableDeclarations.get(binding) != null)
        checks.add(
            new LocalVariableReferenceCheck(
                file,
                jdtTypingProvider,
                bridge(node),
                knownVariableDeclarations.get(binding),
                node.toString()));
    }
    super.visitName(node);
  }
  private void possibleStaticImportFound(Name name) {
    if (fStaticImports == null || fASTRoot == null) {
      return;
    }

    while (name.isQualifiedName()) {
      name = ((QualifiedName) name).getQualifier();
    }
    if (!isAffected(name)) {
      return;
    }

    IBinding binding = name.resolveBinding();
    SimpleName simpleName = (SimpleName) name;
    if (binding == null
        || binding instanceof ITypeBinding
        || !Modifier.isStatic(binding.getModifiers())
        || simpleName.isDeclaration()) {
      return;
    }

    if (binding instanceof IVariableBinding) {
      IVariableBinding varBinding = (IVariableBinding) binding;
      if (varBinding.isField()) {
        varBinding = varBinding.getVariableDeclaration();
        ITypeBinding declaringClass = varBinding.getDeclaringClass();
        if (declaringClass != null && !declaringClass.isLocal()) {
          if (new ScopeAnalyzer(fASTRoot)
              .isDeclaredInScope(
                  varBinding, simpleName, ScopeAnalyzer.VARIABLES | ScopeAnalyzer.CHECK_VISIBILITY))
            return;
          fStaticImports.add(simpleName);
        }
      }
    } else if (binding instanceof IMethodBinding) {
      IMethodBinding methodBinding = ((IMethodBinding) binding).getMethodDeclaration();
      ITypeBinding declaringClass = methodBinding.getDeclaringClass();
      if (declaringClass != null && !declaringClass.isLocal()) {
        if (new ScopeAnalyzer(fASTRoot)
            .isDeclaredInScope(
                methodBinding, simpleName, ScopeAnalyzer.METHODS | ScopeAnalyzer.CHECK_VISIBILITY))
          return;
        fStaticImports.add(simpleName);
      }
    }
  }
 private void typeRefFound(Name node) {
   if (node != null) {
     while (node.isQualifiedName()) {
       node = ((QualifiedName) node).getQualifier();
     }
     addReference((SimpleName) node);
   }
 }
예제 #8
0
  @Override
  public boolean visit(NormalAnnotation node) {
    //
    // Test method?
    //
    if (isTestAnnotation(node.getTypeName().toString())) {
      ASTNode parent = node.getParent();
      if (parent instanceof MethodDeclaration) {
        addTestMethod((MethodDeclaration) parent, JDK15_ANNOTATION);
      } else if (parent instanceof TypeDeclaration) {
        m_typeIsTest = true;
        m_annotationType = JDK15_ANNOTATION;
      }

      List pairs = node.values();
      for (Iterator it = pairs.iterator(); it.hasNext(); ) {
        MemberValuePair mvp = (MemberValuePair) it.next();
        Name attribute = mvp.getName();
        String name = attribute.getFullyQualifiedName();
        if ("groups".equals(name)) {
          Expression value = mvp.getValue();
          // Array?
          if (value instanceof ArrayInitializer) {
            ArrayInitializer ai = (ArrayInitializer) value;
            List expressions = ai.expressions();
            for (Iterator it2 = expressions.iterator(); it2.hasNext(); ) {
              Expression e = (Expression) it2.next();
              addGroup(e.toString());
            }
          } else if (value instanceof SimpleName) {
            Object boundValue = value.resolveConstantExpressionValue();
            addGroup(boundValue.toString());
          } else if (value instanceof StringLiteral) {
            addGroup(value.toString());
          }
        }
      }
    } else if (isFactoryAnnotation(node.getTypeName().toString())) {
      if (node.getParent() instanceof MethodDeclaration) {
        m_annotationType = JDK15_ANNOTATION;
        addFactoryMethod((MethodDeclaration) node.getParent(), JDK15_ANNOTATION);
      }
    }

    return false;
  }
 // !! - like one in ExtractTempRefactoring
 private static boolean canReplace(IASTFragment fragment) {
   ASTNode node = fragment.getAssociatedNode();
   ASTNode parent = node.getParent();
   if (parent instanceof VariableDeclarationFragment) {
     VariableDeclarationFragment vdf = (VariableDeclarationFragment) parent;
     if (node.equals(vdf.getName())) return false;
   }
   if (parent instanceof ExpressionStatement) return false;
   if (parent instanceof SwitchCase) {
     if (node instanceof Name) {
       Name name = (Name) node;
       ITypeBinding typeBinding = name.resolveTypeBinding();
       if (typeBinding != null) {
         return !typeBinding.isEnum();
       }
     }
   }
   return true;
 }
예제 #10
0
  /**
   * generate checks accordingly.
   *
   * @param node
   * @param binding
   * @param declTypeBinding
   */
  private void handleInheritedAbstractMethodImplementation(
      MethodDeclaration node, IMethodBinding methodBinding, List<MethodPathItem> inhMethods) {

    // add check for method name
    checks.add(
        new MethodImplementationNameCheck(
            file, jdtTypingProvider, bridge(node), methodBinding, inhMethods));

    // add checks for parameters
    List parameterList = node.parameters();

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

      checks.add(
          new MethodImplementationParameterCheck(
              file,
              jdtTypingProvider,
              bridge((SingleVariableDeclaration) parameterList.get(j)),
              methodBinding,
              j,
              inhMethods));
    }

    // add checks for exceptions
    List exceptionList = node.thrownExceptions();
    Name curExcNode;
    for (int i = 0; i < exceptionList.size(); i++) {

      curExcNode = (Name) exceptionList.get(i);
      ITypeBinding curExcBinding = curExcNode.resolveTypeBinding();

      if (curExcBinding == null) continue;

      checks.add(
          new MethodImplementationExceptionCheck(
              file,
              jdtTypingProvider,
              bridge(curExcNode),
              methodBinding,
              curExcBinding.getKey(),
              inhMethods));
    }
  }
예제 #11
0
  private static ASTNode getRawReference(
      MethodInvocation invocation, CompilationUnit compilationUnit) {
    Name name1 = (Name) invocation.getStructuralProperty(MethodInvocation.NAME_PROPERTY);
    if (name1 instanceof SimpleName) {
      ASTNode rawReference = getRawReference((SimpleName) name1, compilationUnit);
      if (rawReference != null) {
        return rawReference;
      }
    }

    Expression expr =
        (Expression) invocation.getStructuralProperty(MethodInvocation.EXPRESSION_PROPERTY);
    if (expr instanceof SimpleName) {
      ASTNode rawReference = getRawReference((SimpleName) expr, compilationUnit);
      if (rawReference != null) {
        return rawReference;
      }
    } else if (expr instanceof QualifiedName) {
      Name name = (Name) expr;
      while (name instanceof QualifiedName) {
        SimpleName simpleName =
            (SimpleName) name.getStructuralProperty(QualifiedName.NAME_PROPERTY);
        ASTNode rawReference = getRawReference(simpleName, compilationUnit);
        if (rawReference != null) {
          return rawReference;
        }
        name = (Name) name.getStructuralProperty(QualifiedName.QUALIFIER_PROPERTY);
      }
      if (name instanceof SimpleName) {
        ASTNode rawReference = getRawReference((SimpleName) name, compilationUnit);
        if (rawReference != null) {
          return rawReference;
        }
      }
    } else if (expr instanceof MethodInvocation) {
      ASTNode rawReference = getRawReference((MethodInvocation) expr, compilationUnit);
      if (rawReference != null) {
        return rawReference;
      }
    }
    return null;
  }
예제 #12
0
  @Override
  protected void visitName(Name node) {
    IBinding binding = node.resolveBinding();

    if (binding != null
        && binding instanceof IVariableBinding
        && ((IVariableBinding) binding).isField()) {
      handleFieldChecks(node, (IVariableBinding) binding);
    }

    super.visitName(node);
  }
  /*
   * Must be one of:
   * <ul>
   * <li>[result].length</li>
   * </ul>
   */
  private boolean validateLengthQuery(Expression lengthQuery) {
    if (lengthQuery instanceof QualifiedName) {
      QualifiedName qualifiedName = (QualifiedName) lengthQuery;
      SimpleName name = qualifiedName.getName();
      if (!LENGTH_QUERY.equals(name.getIdentifier())) return false;

      Name arrayAccess = qualifiedName.getQualifier();
      ITypeBinding accessType = arrayAccess.resolveTypeBinding();
      if (accessType == null) return false;

      if (!accessType.isArray()) return false;

      IBinding arrayBinding = arrayAccess.resolveBinding();
      if (arrayBinding == null) return false;

      fArrayBinding = arrayBinding;
      fArrayAccess = arrayAccess;
      return true;
    } else if (lengthQuery instanceof FieldAccess) {
      FieldAccess fieldAccess = (FieldAccess) lengthQuery;
      SimpleName name = fieldAccess.getName();
      if (!LENGTH_QUERY.equals(name.getIdentifier())) return false;

      Expression arrayAccess = fieldAccess.getExpression();
      ITypeBinding accessType = arrayAccess.resolveTypeBinding();
      if (accessType == null) return false;

      if (!accessType.isArray()) return false;

      IBinding arrayBinding = getBinding(arrayAccess);
      if (arrayBinding == null) return false;

      fArrayBinding = arrayBinding;
      fArrayAccess = arrayAccess;
      return true;
    }

    return false;
  }
예제 #14
0
  private void handleOverridingRelationshipViolation(
      MethodDeclaration node, IMethodBinding methodBinding, List<MethodPathItem> inhMethods) {

    // get first overridden item
    MethodPathItem superItem = OverridingRelationUtils.getFirstNonAbstractItem(inhMethods);

    if (superItem == null) return;

    // add check for method name and params
    checks.add(
        new InheritedMethodCheck(
            file,
            jdtTypingProvider,
            bridge(node),
            OverridingRelationUtils.getIASTNodeList(node.parameters()),
            methodBinding.getName(),
            superItem));

    // get all keys of method exceptions in super classes which are cast
    // compatible to exceptions of "node"
    // the list should contain at least one overridden exception key
    List exceptionList = node.thrownExceptions();
    Name curExcNode;
    for (int i = 0; i < exceptionList.size(); i++) {

      curExcNode = (Name) exceptionList.get(i);
      ITypeBinding curExcBinding = curExcNode.resolveTypeBinding();

      if (curExcBinding == null) continue;

      checks.add(
          new InheritedMethodExceptionCheck(
              file,
              jdtTypingProvider,
              bridge(curExcNode),
              curExcBinding.getName(),
              superItem.getInheritedExceptionKeys(methodBinding).get(curExcBinding.getKey())));
    }
  }
 @Override
 public void endVisit(CompilationUnit node) {
   RefactoringStatus status = getStatus();
   superCall:
   {
     if (status.hasFatalError()) break superCall;
     if (!hasSelectedNodes()) {
       ASTNode coveringNode = getLastCoveringNode();
       if (coveringNode instanceof Block
           && coveringNode.getParent() instanceof MethodDeclaration) {
         MethodDeclaration methodDecl = (MethodDeclaration) coveringNode.getParent();
         Message[] messages = ASTNodes.getMessages(methodDecl, ASTNodes.NODE_ONLY);
         if (messages.length > 0) {
           status.addFatalError(
               Messages.format(
                   RefactoringCoreMessages.ExtractMethodAnalyzer_compile_errors,
                   BasicElementLabels.getJavaElementName(methodDecl.getName().getIdentifier())),
               JavaStatusContext.create(fCUnit, methodDecl));
           break superCall;
         }
       }
       status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_invalid_selection);
       break superCall;
     }
     fEnclosingBodyDeclaration =
         (BodyDeclaration) ASTNodes.getParent(getFirstSelectedNode(), BodyDeclaration.class);
     if (fEnclosingBodyDeclaration == null
         || (fEnclosingBodyDeclaration.getNodeType() != ASTNode.METHOD_DECLARATION
             && fEnclosingBodyDeclaration.getNodeType() != ASTNode.FIELD_DECLARATION
             && fEnclosingBodyDeclaration.getNodeType() != ASTNode.INITIALIZER)) {
       status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_invalid_selection);
       break superCall;
     } else if (ASTNodes.getEnclosingType(fEnclosingBodyDeclaration) == null) {
       status.addFatalError(
           RefactoringCoreMessages.ExtractMethodAnalyzer_compile_errors_no_parent_binding);
       break superCall;
     } else if (fEnclosingBodyDeclaration.getNodeType() == ASTNode.METHOD_DECLARATION) {
       fEnclosingMethodBinding = ((MethodDeclaration) fEnclosingBodyDeclaration).resolveBinding();
     }
     if (!isSingleExpressionOrStatementSet()) {
       status.addFatalError(
           RefactoringCoreMessages.ExtractMethodAnalyzer_single_expression_or_set);
       break superCall;
     }
     if (isExpressionSelected()) {
       ASTNode expression = getFirstSelectedNode();
       if (expression instanceof Name) {
         Name name = (Name) expression;
         if (name.resolveBinding() instanceof ITypeBinding) {
           status.addFatalError(
               RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_type_reference);
           break superCall;
         }
         if (name.resolveBinding() instanceof IMethodBinding) {
           status.addFatalError(
               RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_method_name_reference);
           break superCall;
         }
         if (name.resolveBinding() instanceof IVariableBinding) {
           StructuralPropertyDescriptor locationInParent = name.getLocationInParent();
           if (locationInParent == QualifiedName.NAME_PROPERTY
               || (locationInParent == FieldAccess.NAME_PROPERTY
                   && !(((FieldAccess) name.getParent()).getExpression()
                       instanceof ThisExpression))) {
             status.addFatalError(
                 RefactoringCoreMessages
                     .ExtractMethodAnalyzer_cannot_extract_part_of_qualified_name);
             break superCall;
           }
         }
         if (name.isSimpleName() && ((SimpleName) name).isDeclaration()) {
           status.addFatalError(
               RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_name_in_declaration);
           break superCall;
         }
       }
       fForceStatic =
           ASTNodes.getParent(expression, ASTNode.SUPER_CONSTRUCTOR_INVOCATION) != null
               || ASTNodes.getParent(expression, ASTNode.CONSTRUCTOR_INVOCATION) != null;
     }
     status.merge(LocalTypeAnalyzer.perform(fEnclosingBodyDeclaration, getSelection()));
     computeLastStatementSelected();
   }
   super.endVisit(node);
 }
  private ClipboardData getClipboardData(ITypeRoot inputElement, int offset, int length) {
    CompilationUnit astRoot =
        SharedASTProvider.getAST(inputElement, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
    if (astRoot == null) {
      return null;
    }

    // do process import if selection spans over import declaration or package
    List<ImportDeclaration> list = astRoot.imports();
    if (!list.isEmpty()) {
      if (offset < ((ASTNode) list.get(list.size() - 1)).getStartPosition()) {
        return null;
      }
    } else if (astRoot.getPackage() != null) {
      if (offset < ((ASTNode) astRoot.getPackage()).getStartPosition()) {
        return null;
      }
    }

    ArrayList<SimpleName> typeImportsRefs = new ArrayList<SimpleName>();
    ArrayList<SimpleName> staticImportsRefs = new ArrayList<SimpleName>();

    ImportReferencesCollector.collect(
        astRoot,
        inputElement.getJavaProject(),
        new Region(offset, length),
        typeImportsRefs,
        staticImportsRefs);

    if (typeImportsRefs.isEmpty() && staticImportsRefs.isEmpty()) {
      return null;
    }

    HashSet<String> namesToImport = new HashSet<String>(typeImportsRefs.size());
    for (int i = 0; i < typeImportsRefs.size(); i++) {
      Name curr = typeImportsRefs.get(i);
      IBinding binding = curr.resolveBinding();
      if (binding != null && binding.getKind() == IBinding.TYPE) {
        ITypeBinding typeBinding = (ITypeBinding) binding;
        if (typeBinding.isArray()) {
          typeBinding = typeBinding.getElementType();
        }
        if (typeBinding.isTypeVariable()
            || typeBinding.isCapture()
            || typeBinding.isWildcardType()) { // can be removed when bug 98473 is fixed
          continue;
        }

        if (typeBinding.isMember() || typeBinding.isTopLevel()) {
          String name = Bindings.getRawQualifiedName(typeBinding);
          if (name.length() > 0) {
            namesToImport.add(name);
          }
        }
      }
    }

    HashSet<String> staticsToImport = new HashSet<String>(staticImportsRefs.size());
    for (int i = 0; i < staticImportsRefs.size(); i++) {
      Name curr = staticImportsRefs.get(i);
      IBinding binding = curr.resolveBinding();
      if (binding != null) {
        StringBuffer buf = new StringBuffer(Bindings.getImportName(binding));
        if (binding.getKind() == IBinding.METHOD) {
          buf.append("()"); // $NON-NLS-1$
        }
        staticsToImport.add(buf.toString());
      }
    }

    if (namesToImport.isEmpty() && staticsToImport.isEmpty()) {
      return null;
    }

    String[] typeImports = namesToImport.toArray(new String[namesToImport.size()]);
    String[] staticImports = staticsToImport.toArray(new String[staticsToImport.size()]);
    return new ClipboardData(inputElement, typeImports, staticImports);
  }
예제 #17
0
  public static void addFinalAndValAnnotationToModifierList(
      Object converter, List<IExtendedModifier> modifiers, AST ast, LocalDeclaration in) {
    // First check that 'in' has the final flag on, and a @val / @lombok.val annotation.
    if ((in.modifiers & ClassFileConstants.AccFinal) == 0) return;
    if (in.annotations == null) return;
    boolean found = false;
    Annotation valAnnotation = null;

    for (Annotation ann : in.annotations) {
      if (PatchVal.couldBeVal(ann.type)) {
        found = true;
        valAnnotation = ann;
        break;
      }
    }

    if (!found) return;

    // Now check that 'out' is missing either of these.

    if (modifiers == null)
      return; // This is null only if the project is 1.4 or less. Lombok doesn't work in that.
    boolean finalIsPresent = false;
    boolean valIsPresent = false;

    for (Object present : modifiers) {
      if (present instanceof Modifier) {
        ModifierKeyword keyword = ((Modifier) present).getKeyword();
        if (keyword == null) continue;
        if (keyword.toFlagValue() == Modifier.FINAL) finalIsPresent = true;
      }

      if (present instanceof org.eclipse.jdt.core.dom.Annotation) {
        Name typeName = ((org.eclipse.jdt.core.dom.Annotation) present).getTypeName();
        if (typeName != null) {
          String fullyQualifiedName = typeName.getFullyQualifiedName();
          if ("val".equals(fullyQualifiedName) || "lombok.val".equals(fullyQualifiedName)) {
            valIsPresent = true;
          }
        }
      }
    }

    if (!finalIsPresent) {
      modifiers.add(
          createModifier(
              ast,
              ModifierKeyword.FINAL_KEYWORD,
              valAnnotation.sourceStart,
              valAnnotation.sourceEnd));
    }

    if (!valIsPresent) {
      MarkerAnnotation newAnnotation =
          createValAnnotation(
              ast, valAnnotation, valAnnotation.sourceStart, valAnnotation.sourceEnd);
      try {
        Reflection.astConverterRecordNodes.invoke(converter, newAnnotation, valAnnotation);
        Reflection.astConverterRecordNodes.invoke(
            converter, newAnnotation.getTypeName(), valAnnotation.type);
      } catch (IllegalAccessException e) {
        throw Lombok.sneakyThrow(e);
      } catch (InvocationTargetException e) {
        throw Lombok.sneakyThrow(e.getCause());
      }
      modifiers.add(newAnnotation);
    }
  }
예제 #18
0
 /* (non-Javadoc)
  * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
  */
 public boolean visit(PackageDeclaration node) {
   Name name = node.getName();
   fPackage = Factory.packageDescriptor(name.getFullyQualifiedName());
   return false;
 }