private CeylonParseController parse() {
   CeylonParseController cpc = new CeylonParseController();
   cpc.initialize(
       editor.getParseController().getPath(), editor.getParseController().getProject(), null);
   cpc.parse(editor.getCeylonSourceViewer().getDocument(), new NullProgressMonitor(), null);
   return cpc;
 }
 static int nextTokenType(CeylonParseController cpc, CommonToken token) {
   for (int i = token.getTokenIndex() + 1; i < cpc.getTokens().size(); i++) {
     CommonToken tok = cpc.getTokens().get(i);
     if (tok.getChannel() != CommonToken.HIDDEN_CHANNEL) {
       return tok.getType();
     }
   }
   return -1;
 }
 static void addPackageDescriptorCompletion(
     CeylonParseController cpc, int offset, String prefix, List<ICompletionProposal> result) {
   if (!"package".startsWith(prefix)) return;
   IFile file = cpc.getProject().getFile(cpc.getPath());
   String packageName = getPackageName(file);
   if (packageName != null) {
     result.add(new PackageDescriptorProposal(offset, prefix, packageName));
   }
 }
  private boolean terminateWithSemicolon() throws Exception {
    final IDocument doc = editor.getCeylonSourceViewer().getDocument();
    final TextChange change = new DocumentChange("Terminate Statement", doc);
    change.setEdit(new MultiTextEdit());
    CeylonParseController parser = parse();
    CompilationUnit rootNode = parser.getRootNode();
    IRegion li = getLineInfo(doc);
    String lineText = doc.get(li.getOffset(), li.getLength());
    final List<CommonToken> tokens = parser.getTokens();
    // final int startOfCodeInLine = getCodeStart(li, lineText, tokens);
    final int endOfCodeInLine = getCodeEnd(li, lineText, tokens);
    if (!doc.get(endOfCodeInLine, 1).equals(";")) {
      new Processor() {
        @Override
        public void visit(Tree.Annotation that) {
          super.visit(that);
          terminateWithSemicolon(that);
        }

        @Override
        public void visit(Tree.StatementOrArgument that) {
          super.visit(that);
          if (that instanceof Tree.ExecutableStatement && !(that instanceof Tree.ControlStatement)
              || that instanceof Tree.AttributeDeclaration
              || that instanceof Tree.MethodDeclaration
              || that instanceof Tree.ClassDeclaration
              || that instanceof Tree.InterfaceDeclaration
              || that instanceof Tree.SpecifiedArgument) {
            terminateWithSemicolon(that);
          }
        }

        private void terminateWithSemicolon(Node that) {
          try {
            if (that.getStartIndex() <= endOfCodeInLine && that.getStopIndex() >= endOfCodeInLine) {
              Token et = that.getEndToken();
              if (et == null
                  || et.getType() != CeylonLexer.SEMICOLON
                  || that.getStopIndex() > endOfCodeInLine) {
                if (!change.getEdit().hasChildren()) {
                  change.addEdit(new InsertEdit(endOfCodeInLine + 1, ";"));
                }
              }
            }
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }.visit(rootNode);
      if (change.getEdit().hasChildren()) {
        change.perform(new NullProgressMonitor());
        return true;
      }
    }
    return false;
  }
 static void addCurrentPackageNameCompletion(
     CeylonParseController cpc, int offset, String prefix, List<ICompletionProposal> result) {
   IFile file = cpc.getProject().getFile(cpc.getPath());
   String moduleName = getPackageName(file);
   if (moduleName != null) {
     result.add(
         new CompletionProposal(
             offset, prefix, isModuleDescriptor(cpc) ? MODULE : PACKAGE, moduleName, moduleName));
   }
 }
  @Override
  protected IStructureComparator createStructureComparator(
      Object input,
      IDocument document,
      ISharedDocumentAdapter sharedDocumentAdapter,
      IProgressMonitor monitor)
      throws CoreException {

    if (input instanceof CeylonDocumentRangeNode) {
      return (CeylonDocumentRangeNode) input;
    }

    final boolean isEditable;
    if (input instanceof IEditableContent) {
      IEditableContent ec = (IEditableContent) input;
      isEditable = ec.isEditable();
    } else {
      isEditable = false;
    }

    StructureRootNode structureRootNode =
        new StructureRootNode(document, input, this, sharedDocumentAdapter) {
          @Override
          public boolean isEditable() {
            return isEditable;
          }
        };

    CeylonParseController pc = new CeylonParseController();
    if (input instanceof ResourceNode) {
      ResourceNode node = (ResourceNode) input;
      IResource file = node.getResource();
      pc.initialize(file.getProjectRelativePath(), file.getProject(), null);
    } else {
      pc.initialize(null, null, null);
    }

    if (pc.parseAndTypecheck(document, 10, monitor, null) != null) {
      // now visit the model, creating TreeCompareNodes for each ModelTreeNode
      CeylonOutlineNode tree =
          new CeylonOutlineBuilder() {
            // don't create nodes for shortcut refinement
            // because we can't distinguish them w/o a
            // full typecheck
            public void visit(Tree.SpecifierStatement that) {}
          }.buildTree(pc);
      if (tree != null) {
        buildCompareTree(tree, structureRootNode, document);
      }
    }

    return structureRootNode;
  }
 @Override
 public boolean isEnabled() {
   IEditorPart editor = getCurrentEditor();
   if (super.isEnabled()
       && editor instanceof CeylonEditor
       && editor.getEditorInput() instanceof IFileEditorInput) {
     CeylonParseController cpc = ((CeylonEditor) editor).getParseController();
     return cpc == null || cpc.getRootNode() == null ? false : true;
     // !cpc.getRootNode().getImportList().getImports().isEmpty();
   }
   return false;
 }
 @Override
 public IHyperlink[] detectHyperlinks(
     ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) {
   if (controller == null || controller.getLastCompilationUnit() == null) {
     return null;
   } else {
     Node node =
         findNode(
             controller.getLastCompilationUnit(),
             controller.getTokens(),
             region.getOffset(),
             region.getOffset() + region.getLength());
     if (node == null) {
       return null;
     } else {
       Node id = getIdentifyingNode(node);
       if (id == null) {
         return null;
       } else {
         Referenceable referenceable = getReferencedModel(node);
         Backends supportedBackends = supportedBackends();
         if (referenceable instanceof Declaration) {
           Declaration dec = (Declaration) referenceable;
           if (dec.isNative()) {
             if (supportedBackends.none()) {
               return null;
             } else {
               referenceable = resolveNative(referenceable, dec, supportedBackends);
             }
           } else {
             if (!supportedBackends.none()) {
               return null;
             }
           }
         } else { // Module or package descriptors
           if (!supportedBackends.none()) {
             return null;
           }
         }
         Node r = getReferencedNode(referenceable);
         if (r == null) {
           return null;
         } else {
           return new IHyperlink[] {new CeylonNodeLink(r, id)};
         }
       }
     }
   }
 }
 static boolean isEmptyPackageDescriptor(CeylonParseController cpc) {
   Tree.CompilationUnit lcu = cpc.getLastCompilationUnit();
   return lcu != null
       && lcu.getUnit() != null
       && lcu.getUnit().getFilename().equals("package.ceylon")
       && lcu.getPackageDescriptors().isEmpty();
 }
Ejemplo n.º 10
0
 static Tree.CompilationUnit getRootNode(PhasedUnit unit) {
   IEditorPart ce = getCurrentEditor();
   if (ce instanceof CeylonEditor) {
     CeylonEditor editor = (CeylonEditor) ce;
     CeylonParseController cpc = editor.getParseController();
     if (cpc != null) {
       Tree.CompilationUnit rn = cpc.getTypecheckedRootNode();
       if (rn != null) {
         Unit u = rn.getUnit();
         if (u.equals(unit.getUnit())) {
           return rn;
         }
       }
     }
   }
   return unit.getCompilationUnit();
 }
 private Tree.Declaration getSelectionTarget(ITextSelection textSel) {
   CeylonEditor editor = (CeylonEditor) getCurrentEditor();
   CeylonParseController pc = editor.getParseController();
   if (pc == null) {
     return null;
   } else {
     Tree.CompilationUnit ast = pc.getRootNode();
     if (ast == null) {
       return null;
     } else {
       Object sourceNode = findNode(ast, textSel.getOffset());
       if (sourceNode == null) {
         return null;
       } else {
         return getReferencedNode(sourceNode, pc);
       }
     }
   }
 }
Ejemplo n.º 12
0
 static boolean isModuleDescriptor(CeylonParseController cpc) {
   Tree.CompilationUnit lcu = cpc.getLastCompilationUnit();
   return lcu != null
       && lcu.getUnit() != null
       && lcu.getUnit().getFilename().equals("module.ceylon");
 }
Ejemplo n.º 13
0
  public static String getInitialValueDescription(
      final Declaration dec, CeylonParseController cpc) {
    if (cpc != null) {
      Node refnode = getReferencedNode(dec);
      Tree.SpecifierOrInitializerExpression sie = null;
      String arrow = null;
      if (refnode instanceof Tree.AttributeDeclaration) {
        Tree.AttributeDeclaration ad = (Tree.AttributeDeclaration) refnode;
        sie = ad.getSpecifierOrInitializerExpression();
        arrow = " = ";
      } else if (refnode instanceof Tree.MethodDeclaration) {
        Tree.MethodDeclaration md = (Tree.MethodDeclaration) refnode;
        sie = md.getSpecifierExpression();
        arrow = " => ";
      }
      Tree.CompilationUnit lcu = cpc.getLastCompilationUnit();
      if (sie == null) {
        class FindInitializerVisitor extends Visitor {
          Tree.SpecifierOrInitializerExpression result;

          @Override
          public void visit(Tree.InitializerParameter that) {
            super.visit(that);
            Declaration d = that.getParameterModel().getModel();
            if (d != null && d.equals(dec)) {
              result = that.getSpecifierExpression();
            }
          }
        }
        FindInitializerVisitor fiv = new FindInitializerVisitor();
        fiv.visit(lcu);
        sie = fiv.result;
      }
      if (sie != null) {
        Tree.Expression e = sie.getExpression();
        if (e != null) {
          Tree.Term term = e.getTerm();
          if (term instanceof Tree.Literal) {
            String text = term.getToken().getText();
            if (text.length() < 20) {
              return arrow + text;
            }
          } else if (term instanceof Tree.BaseMemberOrTypeExpression) {
            Tree.BaseMemberOrTypeExpression bme = (Tree.BaseMemberOrTypeExpression) term;
            Tree.Identifier id = bme.getIdentifier();
            if (id != null && bme.getTypeArguments() == null) {
              return arrow + id.getText();
            }
          } else if (term != null) {
            Unit unit = lcu.getUnit();
            if (term.getUnit().equals(unit)) {
              String impl = Nodes.text(term, cpc.getTokens());
              if (impl.length() < 10) {
                return arrow + impl;
              }
            }
          }
          // don't have the token stream :-/
          // TODO: figure out where to get it from!
          return arrow + "...";
        }
      }
    }
    return "";
  }
Ejemplo n.º 14
0
 static boolean isEmptyModuleDescriptor(CeylonParseController cpc) {
   Tree.CompilationUnit lcu = cpc.getLastCompilationUnit();
   return isModuleDescriptor(cpc) && lcu != null && lcu.getModuleDescriptors().isEmpty();
 }
  private boolean terminateWithBrace() throws Exception {
    IDocument doc = editor.getCeylonSourceViewer().getDocument();
    final TextChange change = new DocumentChange("Terminate Statement", doc);
    change.setEdit(new MultiTextEdit());
    CeylonParseController parser = parse();
    CompilationUnit rootNode = parser.getRootNode();
    IRegion li = getLineInfo(doc);
    final String lineText = doc.get(li.getOffset(), li.getLength());
    final List<CommonToken> tokens = parser.getTokens();
    final int startOfCodeInLine = getCodeStart(li, lineText, tokens);
    final int endOfCodeInLine = getCodeEnd(li, lineText, tokens);
    new Processor() {
      @Override
      public void visit(Tree.Expression that) {
        super.visit(that);
        if (that.getStopIndex() <= endOfCodeInLine && that.getStartIndex() >= startOfCodeInLine) {
          Token et = that.getMainEndToken();
          Token st = that.getMainToken();
          if (st != null
              && st.getType() == CeylonLexer.LPAREN
              && (et == null || et.getType() != CeylonLexer.RPAREN)) {
            if (!change.getEdit().hasChildren()) {
              change.addEdit(new InsertEdit(that.getStopIndex() + 1, ")"));
            }
          }
        }
      }

      @Override
      public void visit(Tree.ParameterList that) {
        super.visit(that);
        terminate(that, CeylonLexer.RPAREN, ")");
      }

      public void visit(Tree.IndexExpression that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACKET, "]");
      }

      @Override
      public void visit(Tree.TypeParameterList that) {
        super.visit(that);
        terminate(that, CeylonLexer.LARGER_OP, ">");
      }

      @Override
      public void visit(Tree.TypeArgumentList that) {
        super.visit(that);
        terminate(that, CeylonLexer.LARGER_OP, ">");
      }

      @Override
      public void visit(Tree.PositionalArgumentList that) {
        super.visit(that);
        if (that.getToken().getType() == CeylonLexer.LPAREN) { // for infix function syntax
          terminate(that, CeylonLexer.RPAREN, ")");
        }
      }

      @Override
      public void visit(Tree.NamedArgumentList that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACE, " }");
      }

      @Override
      public void visit(Tree.SequenceEnumeration that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACE, " }");
      }

      @Override
      public void visit(Tree.IterableType that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACE, "}");
      }

      @Override
      public void visit(Tree.Tuple that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACKET, "]");
      }

      @Override
      public void visit(Tree.TupleType that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACKET, "]");
      }

      @Override
      public void visit(Tree.ConditionList that) {
        super.visit(that);
        initiate(that, CeylonLexer.LPAREN, "(");
        // does not really work right:
        terminate(that, CeylonLexer.RPAREN, ")");
      }

      @Override
      public void visit(Tree.ForIterator that) {
        super.visit(that);
        initiate(that, CeylonLexer.LPAREN, "(");
        // does not really work right:
        terminate(that, CeylonLexer.RPAREN, ")");
      }

      @Override
      public void visit(Tree.ImportMemberOrTypeList that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACE, " }");
      }

      @Override
      public void visit(Tree.ImportModule that) {
        super.visit(that);
        terminate(that, CeylonLexer.SEMICOLON, ";");
      }

      @Override
      public void visit(Tree.ImportModuleList that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACE, " }");
      }

      @Override
      public void visit(Tree.PackageDescriptor that) {
        super.visit(that);
        terminate(that, CeylonLexer.SEMICOLON, ";");
      }

      @Override
      public void visit(Tree.Body that) {
        super.visit(that);
        terminate(that, CeylonLexer.RBRACE, " }");
      }

      @Override
      public void visit(Tree.StatementOrArgument that) {
        super.visit(that);
        if (
        /*that instanceof Tree.ExecutableStatement &&
        	!(that instanceof Tree.ControlStatement) ||
        that instanceof Tree.AttributeDeclaration ||
        that instanceof Tree.MethodDeclaration ||
        that instanceof Tree.ClassDeclaration ||
        that instanceof Tree.InterfaceDeclaration ||*/
        that instanceof Tree.SpecifiedArgument) {
          terminate(that, CeylonLexer.SEMICOLON, ";");
        }
      }

      private void initiate(Node that, int tokenType, String ch) {
        if (that.getStartIndex() >= startOfCodeInLine && that.getStartIndex() <= endOfCodeInLine) {
          Token et = that.getMainToken();
          if (et == null || et.getType() != tokenType || et.getText().startsWith("<missing ")) {
            if (!change.getEdit().hasChildren()) {
              change.addEdit(new InsertEdit(that.getStartIndex(), ch));
            }
          }
        }
      }

      private void terminate(Node that, int tokenType, String ch) {
        if (that.getStartIndex() >= startOfCodeInLine && that.getStartIndex() <= endOfCodeInLine) {
          Token et = that.getMainEndToken();
          if ((et == null || et.getType() != tokenType) || that.getStopIndex() > endOfCodeInLine) {
            if (!change.getEdit().hasChildren()) {
              change.addEdit(new InsertEdit(min(endOfCodeInLine, that.getStopIndex()) + 1, ch));
            }
          }
        }
      }
    }.visit(rootNode);
    if (change.getEdit().hasChildren()) {
      change.perform(new NullProgressMonitor());
      return true;
    }
    return false;
  }