private static void getAllMethods(
     ClassOrInterface c, TypeDeclaration t, List<MethodWithContainer> members) {
   for (Declaration d : t.getMembers()) {
     if (d instanceof Function) {
       Function m = (Function) d;
       boolean contains = false;
       for (MethodWithContainer member : members) {
         if (member.getMethod().getName().equals(m.getName())) {
           contains = true;
           break;
         }
       }
       if (!contains) {
         members.add(new MethodWithContainer(c, m));
       }
     }
   }
   Type et = t.getExtendedType();
   if (et != null) {
     getAllMethods(c, et.getDeclaration(), members);
   }
   for (Type st : t.getSatisfiedTypes()) {
     getAllMethods(c, st.getDeclaration(), members);
   }
 }
Example #2
0
 private void importMembers(Tree.ImportMemberOrType member, Declaration d) {
   Tree.ImportMemberOrTypeList imtl = member.getImportMemberOrTypeList();
   if (imtl != null) {
     if (d instanceof Value) {
       Value v = (Value) d;
       TypeDeclaration td = v.getTypeDeclaration();
       if (td.isObjectClass()) {
         d = td;
       }
     }
     if (d instanceof TypeDeclaration) {
       Set<String> names = new HashSet<String>();
       ImportList til = imtl.getImportList();
       TypeDeclaration td = (TypeDeclaration) d;
       til.setImportedScope(td);
       List<Tree.ImportMemberOrType> imts = imtl.getImportMemberOrTypes();
       for (Tree.ImportMemberOrType imt : imts) {
         names.add(importMember(imt, td, til));
       }
       if (imtl.getImportWildcard() != null) {
         importAllMembers(td, names, til);
       } else if (imts.isEmpty()) {
         imtl.addError("empty import list", 1020);
       }
     } else {
       imtl.addError("member alias list must follow a type");
     }
   }
 }
Example #3
0
 @Override
 public void visit(Tree.BaseType that) {
   TypeDeclaration d = that.getDeclarationModel();
   if (d != null && d.equals(dec)) {
     detected = true;
   }
 }
 static String getDescription(Declaration dec) {
   String desc = "'" + dec.getName() + "'";
   Scope container = dec.getContainer();
   if (container instanceof TypeDeclaration) {
     TypeDeclaration td = (TypeDeclaration) container;
     desc += " in '" + td.getName() + "'";
   }
   return desc;
 }
Example #5
0
 private static boolean isLegalAliasFreeImport(Declaration dec, Declaration importedDec) {
   if (importedDec instanceof Value) {
     Value value = (Value) importedDec;
     TypeDeclaration td = value.getTypeDeclaration();
     return td.isObjectClass() && td.equals(dec);
   } else {
     return false;
   }
 }
 @Override
 public Object[] getChildren(Object element) {
   if (element instanceof CeylonOutlineNode) {
     if (mode) {
       boolean includeParameters = !CeylonPlugin.getPreferences().getBoolean(PARAMS_IN_OUTLINES);
       CeylonOutlineNode node = (CeylonOutlineNode) element;
       CompilationUnit rootNode = getEditor().getParseController().getLastCompilationUnit();
       Node treeNode = Nodes.findNode(rootNode, node.getStartOffset(), node.getEndOffset());
       TypeDeclaration td;
       if (treeNode instanceof ClassOrInterface) {
         ClassOrInterface ci = (ClassOrInterface) treeNode;
         td = ci.getDeclarationModel();
       } else if (treeNode instanceof ObjectDefinition) {
         ObjectDefinition od = (ObjectDefinition) treeNode;
         td = od.getDeclarationModel().getTypeDeclaration();
       } else {
         return super.getChildren(element);
       }
       List<Declaration> list = new ArrayList<Declaration>();
       String filter = getFilterText().getText();
       for (int i = 0; i < filter.length(); i++) {
         char ch = filter.charAt(i);
         if (ch == '*' || i > 0 && Character.isUpperCase(ch)) {
           filter = filter.substring(0, i);
           break;
         }
       }
       Collection<DeclarationWithProximity> members =
           td.getMatchingMemberDeclarations(rootNode.getUnit(), td, filter, 0, null).values();
       for (DeclarationWithProximity dwp : members) {
         for (Declaration dec : overloads(dwp.getDeclaration())) {
           if (!(dec instanceof TypeParameter)) {
             if (includeParameters || !dec.isParameter()) {
               list.add(dec);
             }
           }
         }
       }
       if (!lexicalSortingAction.isChecked()) {
         Collections.sort(
             list,
             new Comparator<Declaration>() {
               public int compare(Declaration x, Declaration y) {
                 String xn = x.getContainer().getQualifiedNameString();
                 String yn = y.getContainer().getQualifiedNameString();
                 return xn.compareTo(yn);
               }
             });
       }
       return list.toArray();
     } else {
       return super.getChildren(element);
     }
   } else {
     return null;
   }
 }
 public static Declaration extractAnonymousClassIfRequired(Declaration d) {
   if (d instanceof Value) {
     Value value = (Value) d;
     TypeDeclaration typeDeclaration = value.getTypeDeclaration();
     if (typeDeclaration instanceof Class && typeDeclaration.isAnonymous()) {
       return typeDeclaration;
     }
   }
   return d;
 }
 public static String[] getAssignableLiterals(Type type, Unit unit) {
   TypeDeclaration dtd = unit.getDefiniteType(type).getDeclaration();
   if (dtd instanceof Class) {
     if (dtd.isInteger()) {
       return new String[] {"0", "1", "2"};
     }
     if (dtd.isByte()) {
       return new String[] {"0.byte", "1.byte"};
     } else if (dtd.isFloat()) {
       return new String[] {"0.0", "1.0", "2.0"};
     } else if (dtd.isString()) {
       return new String[] {"\"\"", "\"\"\"\"\"\""};
     } else if (dtd.isCharacter()) {
       return new String[] {"' '", "'\\n'", "'\\t'"};
     } else {
       return new String[0];
     }
   } else if (dtd instanceof Interface) {
     if (dtd.isIterable()) {
       return new String[] {"{}"};
     } else if (dtd.isSequential() || dtd.isEmpty()) {
       return new String[] {"[]"};
     } else {
       return new String[0];
     }
   } else {
     return new String[0];
   }
 }
Example #9
0
 public static Declaration getRefinedDeclaration(Declaration declaration) {
   // Reproduces the algorithm used to build the type hierarchy
   // first walk up the superclass hierarchy
   if (declaration.isClassOrInterfaceMember() && declaration.isShared()) {
     TypeDeclaration dec = (TypeDeclaration) declaration.getContainer();
     List<Type> signature = getSignature(declaration);
     Declaration refined = declaration.getRefinedDeclaration();
     while (dec != null) {
       Type extended = dec.getExtendedType();
       if (extended != null) {
         TypeDeclaration superDec = extended.getDeclaration();
         Declaration superMemberDec =
             superDec.getDirectMember(declaration.getName(), signature, false);
         if (superMemberDec != null) {
           Declaration superRefined = superMemberDec.getRefinedDeclaration();
           if (superRefined != null
               && refined != null
               && !isAbstraction(superMemberDec)
               && superRefined.equals(refined)) {
             return superMemberDec;
           }
         }
         dec = superDec;
       } else {
         dec = null;
       }
     }
     // now look at the very top of the hierarchy, even if it is an interface
     Declaration refinedDeclaration = refined;
     if (refinedDeclaration != null && !declaration.equals(refinedDeclaration)) {
       List<Declaration> directlyInheritedMembers =
           getInterveningRefinements(
               declaration.getName(),
               signature,
               refinedDeclaration,
               (TypeDeclaration) declaration.getContainer(),
               (TypeDeclaration) refinedDeclaration.getContainer());
       directlyInheritedMembers.remove(refinedDeclaration);
       // TODO: do something for the case of
       //      multiple intervening interfaces?
       if (directlyInheritedMembers.size() == 1) {
         // exactly one intervening interface
         return directlyInheritedMembers.get(0);
       } else {
         // no intervening interfaces
         return refinedDeclaration;
       }
     }
   }
   return null;
 }
 static String defaultValue(Unit unit, Type t) {
   if (isTypeUnknown(t)) {
     return "nothing";
   }
   if (unit.isOptionalType(t)) {
     return "null";
   }
   if (t.isTypeAlias() || t.isClassOrInterface() && t.getDeclaration().isAlias()) {
     return defaultValue(unit, t.getExtendedType());
   }
   if (t.isClass()) {
     TypeDeclaration c = t.getDeclaration();
     if (c.equals(unit.getBooleanDeclaration())) {
       return "false";
     } else if (c.equals(unit.getIntegerDeclaration())) {
       return "0";
     } else if (c.equals(unit.getFloatDeclaration())) {
       return "0.0";
     } else if (c.equals(unit.getStringDeclaration())) {
       return "\"\"";
     } else if (c.equals(unit.getByteDeclaration())) {
       return "0.byte";
     } else if (c.equals(unit.getTupleDeclaration())) {
       final int minimumLength = unit.getTupleMinimumLength(t);
       final List<Type> tupleTypes = unit.getTupleElementTypes(t);
       final StringBuilder sb = new StringBuilder();
       for (int i = 0; i < minimumLength; i++) {
         sb.append(sb.length() == 0 ? "[" : ", ");
         Type currentType = tupleTypes.get(i);
         if (unit.isSequentialType(currentType)) {
           currentType = unit.getSequentialElementType(currentType);
         }
         sb.append(defaultValue(unit, currentType));
       }
       sb.append(']');
       return sb.toString();
     } else if (unit.isSequentialType(t)) {
       final StringBuilder sb = new StringBuilder();
       sb.append('[');
       if (!unit.getEmptyType().isSubtypeOf(t)) {
         sb.append(defaultValue(unit, unit.getSequentialElementType(t)));
       }
       sb.append(']');
       return sb.toString();
     } else if (unit.isIterableType(t)) {
       final StringBuilder sb = new StringBuilder();
       sb.append('{');
       if (!unit.getEmptyType().isSubtypeOf(t)) {
         sb.append(defaultValue(unit, unit.getIteratedType(t)));
       }
       sb.append('}');
       return sb.toString();
     } else {
       return "nothing";
     }
   } else {
     return "nothing";
   }
 }
 @Override
 public void visit(Tree.TypedDeclaration that) {
   super.visit(that);
   Tree.Identifier id = that.getIdentifier();
   if (id != null) {
     Type type = that.getType().getTypeModel();
     if (type != null) {
       TypeDeclaration td = type.getDeclaration();
       if ((td instanceof ClassOrInterface || td instanceof TypeParameter)
           && td.equals(declaration)) {
         String text = id.getText();
         String name = declaration.getName();
         if (text.equalsIgnoreCase(name) || text.endsWith(name)) {
           identifiers.add(id);
         }
       }
     }
   }
 }
 static boolean isIgnoredLanguageModuleType(TypeDeclaration td) {
   return !td.isObject()
       && !td.isAnything()
       && !td.isString()
       && !td.isInteger()
       && !td.isCharacter()
       && !td.isFloat()
       && !td.isBoolean();
 }
Example #13
0
 private void importAllMembers(
     TypeDeclaration importedType, Set<String> ignoredMembers, ImportList til) {
   for (Declaration dec : importedType.getMembers()) {
     if (dec.isShared()
         && (dec.isStaticallyImportable() || isConstructor(dec))
         && isResolvable(dec)
         && !ignoredMembers.contains(dec.getName())) {
       addWildcardImport(til, dec, importedType);
     }
   }
 }
Example #14
0
 /**
  * See #547 - a generic actual method that has different names in its type parameters as the one
  * it's refining, can receive the type arguments of the parent instead.
  */
 static void addParentMethodTypeParameters(final Function m, final GenerateJsVisitor gen) {
   List<TypeParameter> tps = m.getTypeParameters();
   if (m.isActual() && tps != null && !tps.isEmpty()) {
     // This gives us the root declaration
     Function sm = (Function) m.getRefinedDeclaration();
     for (int i = 0; i < tps.size(); i++) {
       boolean end = false;
       end |= copyMissingTypeParameters(m, sm, i, true, gen);
       // We still need to find intermediate declarations
       if (m.isClassOrInterfaceMember()) {
         final Set<Declaration> decs = new HashSet<Declaration>();
         decs.add(sm);
         decs.add(m);
         // This gives us the containing type
         TypeDeclaration cont = ModelUtil.getContainingClassOrInterface(m);
         for (TypeDeclaration sup : cont.getSupertypeDeclarations()) {
           Declaration d = sup.getDirectMember(m.getName(), null, false);
           if (d instanceof Function && !decs.contains(d)) {
             decs.add(d);
             end |= copyMissingTypeParameters(m, (Function) d, i, false, gen);
           }
         }
         for (Type sup : cont.getSatisfiedTypes()) {
           Declaration d = sup.getDeclaration().getDirectMember(m.getName(), null, false);
           if (d instanceof Function && !decs.contains(d)) {
             decs.add(d);
             end |= copyMissingTypeParameters(m, (Function) d, i, false, gen);
           }
         }
       }
       if (end) {
         gen.endLine(true);
       }
     }
   }
 }
Example #15
0
 private String importMember(Tree.ImportMemberOrType member, TypeDeclaration td, ImportList il) {
   Tree.Identifier id = member.getIdentifier();
   if (id == null) {
     return null;
   }
   Import i = new Import();
   member.setImportModel(i);
   Tree.Alias alias = member.getAlias();
   String name = name(id);
   if (alias == null) {
     i.setAlias(name);
   } else {
     i.setAlias(name(alias.getIdentifier()));
   }
   Declaration m = td.getMember(name, null, false);
   if (m == null) {
     String correction = correct(td, null, unit, name);
     String message = correction == null ? "" : " (did you mean '" + correction + "'?)";
     id.addError(
         "imported declaration not found: '" + name + "' of '" + td.getName() + "'" + message,
         100);
     unit.getUnresolvedReferences().add(id);
   } else {
     List<Declaration> members = m.getContainer().getMembers();
     for (Declaration d : members) {
       String dn = d.getName();
       if (dn != null && dn.equals(name) && !d.sameKind(m) && !d.isAnonymous()) {
         // crazy interop cases like isOpen() + open()
         id.addError("ambiguous member declaration: '" + name + "' of '" + td.getName() + "'");
         return null;
       }
     }
     if (!m.isShared()) {
       id.addError(
           "imported declaration is not shared: '" + name + "' of '" + td.getName() + "'", 400);
     } else if (!declaredInPackage(m, unit)) {
       if (m.isPackageVisibility()) {
         id.addError(
             "imported package private declaration is not visible: '"
                 + name
                 + "' of '"
                 + td.getName()
                 + "'");
       } else if (m.isProtectedVisibility()) {
         id.addError(
             "imported protected declaration is not visible: '"
                 + name
                 + "' of '"
                 + td.getName()
                 + "'");
       }
     }
     i.setTypeDeclaration(td);
     if (!m.isStaticallyImportable()
         && !isToplevelClassConstructor(td, m)
         && !isToplevelAnonymousClass(m.getContainer())) {
       if (alias == null) {
         member.addError("does not specify an alias");
       }
     }
     i.setDeclaration(m);
     member.setDeclarationModel(m);
     if (il.hasImport(m)) {
       id.addError("already imported: '" + name + "' of '" + td.getName() + "'");
     } else {
       if (m.isStaticallyImportable()
           || isToplevelClassConstructor(td, m)
           || isToplevelAnonymousClass(m.getContainer())) {
         if (!checkForHiddenToplevel(id, i, alias)) {
           addImport(member, il, i);
         }
       } else {
         addMemberImport(member, il, i);
       }
     }
     checkAliasCase(alias, m);
   }
   if (m != null) {
     importMembers(member, m);
   }
   // imtl.addError("member aliases may not have member aliases");
   return name;
 }
  @Deprecated
  // replaced by RefineFormalMembersQuickFix.ceylon
  private void refineFormalMembers(IDocument document) throws ExecutionException {
    if (rootNode == null) return;
    TextChange change = new DocumentChange("Refine Members", document);
    change.setEdit(new MultiTextEdit());
    // TODO: copy/pasted from CeylonQuickFixAssistant
    Tree.Body body;
    int offset;
    if (node instanceof Tree.ClassDefinition) {
      ClassDefinition classDefinition = (Tree.ClassDefinition) node;
      body = classDefinition.getClassBody();
      offset = -1;
    } else if (node instanceof Tree.InterfaceDefinition) {
      Tree.InterfaceDefinition interfaceDefinition = (Tree.InterfaceDefinition) node;
      body = interfaceDefinition.getInterfaceBody();
      offset = -1;
    } else if (node instanceof Tree.ObjectDefinition) {
      Tree.ObjectDefinition objectDefinition = (Tree.ObjectDefinition) node;
      body = objectDefinition.getClassBody();
      offset = -1;
    } else if (node instanceof Tree.ObjectExpression) {
      Tree.ObjectExpression objectExpression = (Tree.ObjectExpression) node;
      body = objectExpression.getClassBody();
      offset = -1;
    } else if (node instanceof Tree.ClassBody || node instanceof Tree.InterfaceBody) {
      body = (Tree.Body) node;
      IEditorPart editor = getCurrentEditor();
      if (editor instanceof CeylonEditor) {
        CeylonEditor ce = (CeylonEditor) editor;
        offset = ce.getSelection().getOffset();
      } else {
        offset = -1;
      }
    } else {
      return;
    }
    if (body == null) {
      return;
    }
    boolean isInterface = body instanceof Tree.InterfaceBody;
    List<Tree.Statement> statements = body.getStatements();
    String indent;
    //        String bodyIndent = getIndent(body, document);
    String bodyIndent = utilJ2C().indents().getIndent(node, document);
    String delim = utilJ2C().indents().getDefaultLineDelimiter(document);
    if (statements.isEmpty()) {
      indent = delim + bodyIndent + utilJ2C().indents().getDefaultIndent();
      if (offset < 0) {
        offset = body.getStartIndex() + 1;
      }
    } else {
      Tree.Statement statement = statements.get(statements.size() - 1);
      indent = delim + utilJ2C().indents().getIndent(statement, document);
      if (offset < 0) {
        offset = statement.getEndIndex();
      }
    }
    StringBuilder result = new StringBuilder();
    Set<Declaration> already = new HashSet<Declaration>();
    ClassOrInterface ci = (ClassOrInterface) node.getScope();
    Unit unit = node.getUnit();
    Set<String> ambiguousNames = new HashSet<String>();
    // TODO: does not return unrefined overloaded
    //      versions of a method with one overlaad
    //      already refined
    Collection<DeclarationWithProximity> proposals =
        ci.getMatchingMemberDeclarations(unit, ci, "", 0).values();
    for (DeclarationWithProximity dwp : proposals) {
      Declaration dec = dwp.getDeclaration();
      for (Declaration d : overloads(dec)) {
        try {
          if (d.isFormal() && ci.isInheritedFromSupertype(d)) {
            appendRefinementText(isInterface, indent, result, ci, unit, d);
            importProposals().importSignatureTypes(d, rootNode, already);
            ambiguousNames.add(d.getName());
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
    for (TypeDeclaration superType : ci.getSupertypeDeclarations()) {
      for (Declaration m : superType.getMembers()) {
        try {
          if (m.getName() != null && m.isShared()) {
            Declaration r = ci.getMember(m.getName(), null, false);
            if ((r == null || !r.refines(m) && !r.getContainer().equals(ci))
                && ambiguousNames.add(m.getName())) {
              appendRefinementText(isInterface, indent, result, ci, unit, m);
              importProposals().importSignatureTypes(m, rootNode, already);
            }
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }

    try {
      if (document.getChar(offset) == '}' && result.length() > 0) {
        result.append(delim).append(bodyIndent);
      }
    } catch (BadLocationException e) {
      e.printStackTrace();
    }
    importProposals().applyImports(change, already, rootNode, document);
    change.addEdit(new InsertEdit(offset, result.toString()));
    change.initializeValidationData(null);
    try {
      getWorkspace().run(new PerformChangeOperation(change), new NullProgressMonitor());
    } catch (CoreException ce) {
      ce.printStackTrace();
    }
  }