@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 List<DeclarationWithProximity> getSortedProposedValues( Scope scope, Unit unit, final String exactName) { Map<String, DeclarationWithProximity> map = scope.getMatchingDeclarations(unit, "", 0, null); if (exactName != null) { for (DeclarationWithProximity dwp : new ArrayList<DeclarationWithProximity>(map.values())) { if (!dwp.isUnimported() && !dwp.isAlias() && isNameMatching(dwp.getName(), exactName)) { map.put(dwp.getName(), new DeclarationWithProximity(dwp.getDeclaration(), -5)); } } } List<DeclarationWithProximity> results = new ArrayList<DeclarationWithProximity>(map.values()); Collections.sort(results, new ArgumentProposalComparator(exactName)); return results; }
@Override public int compare(DeclarationWithProximity x, DeclarationWithProximity y) { String xname = x.getName(); String yname = y.getName(); if (exactName != null) { boolean xhit = xname.equals(exactName); boolean yhit = yname.equals(exactName); if (xhit && !yhit) { return -1; } if (yhit && !xhit) { return 1; } xhit = isNameMatching(xname, exactName); yhit = isNameMatching(yname, exactName); if (xhit && !yhit) { return -1; } if (yhit && !xhit) { return 1; } } Declaration xd = x.getDeclaration(); Declaration yd = y.getDeclaration(); boolean xdepr = xd.isDeprecated(); boolean ydepr = yd.isDeprecated(); if (xdepr && !ydepr) { return 1; } if (!xdepr && ydepr) { return -1; } int xp = x.getProximity(); int yp = y.getProximity(); int p = xp - yp; if (p != 0) { return p; } int c = xname.compareTo(yname); if (c != 0) { return c; } return xd.getQualifiedNameString().compareTo(yd.getQualifiedNameString()); }
@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(); } }