/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.ruta.ide.core.codeassist;
import java.util.ArrayList;
import java.util.List;
import org.apache.uima.ruta.ide.core.extensions.ICompletionExtension;
import org.apache.uima.ruta.ide.core.parser.RutaParseUtils;
import org.apache.uima.ruta.ide.parser.ast.RutaStatement;
import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.ASTVisitor;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
import org.eclipse.dltk.ast.declarations.TypeDeclaration;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.references.SimpleReference;
import org.eclipse.dltk.ast.statements.Block;
import org.eclipse.dltk.ast.statements.Statement;
import org.eclipse.dltk.codeassist.complete.CompletionNodeFound;
import org.eclipse.dltk.compiler.env.IModuleSource;
public class RutaCompletionParser extends RutaAssistParser {
private static class RutaEmptyCompleteStatement extends RutaStatement {
public RutaEmptyCompleteStatement(List expressions) {
super(expressions);
}
}
private ICompletionExtension[] extensions;
public RutaCompletionParser(ICompletionExtension[] extensions) {
this.extensions = extensions;
}
/**
* Called then element could not be found.
*/
public void handleNotInElement(ASTNode node, int position) {
if (node != null && node.sourceStart() <= position && position <= node.sourceEnd()) {
// this is empty module case
if (node instanceof ModuleDeclaration) {
ModuleDeclaration unit = (ModuleDeclaration) node;
List exprs = new ArrayList();
exprs.add(new SimpleReference(position, position, ""));
RutaEmptyCompleteStatement statement = new RutaEmptyCompleteStatement(exprs);
unit.addStatement(statement);
this.parseBlockStatements(statement, unit, position);
} else if (node instanceof MethodDeclaration) {
// empty keyword like completion.
MethodDeclaration method = (MethodDeclaration) node;
List exprs = new ArrayList();
exprs.add(new SimpleReference(position, position, ""));
RutaEmptyCompleteStatement statement = new RutaEmptyCompleteStatement(exprs);
method.getStatements().add(statement);
this.parseBlockStatements(statement, method, position);
} else if (node instanceof TypeDeclaration) {
// empty keyword like completion.
TypeDeclaration type = (TypeDeclaration) node;
List exprs = new ArrayList();
exprs.add(new SimpleReference(position, position, ""));
RutaEmptyCompleteStatement statement = new RutaEmptyCompleteStatement(exprs);
type.getStatements().add(statement);
// this.assistNodeParent = node;
this.parseBlockStatements(statement, type, position);
// } else if (node instanceof RutaExecuteExpression) {
// // empty keyword like completion.
// List exprs = new ArrayList();
// exprs.add(new SimpleReference(position, position, ""));
// RutaEmptyCompleteStatement statement = new
// RutaEmptyCompleteStatement(
// exprs);
// this.parseBlockStatements(statement, node, position);
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.dltk.codeassist.IAssistParser#parseBlockStatements(org.eclipse.dltk.ast.ASTNode,
* org.eclipse.dltk.ast.ASTNode, int)
*/
public void parseBlockStatements(ASTNode node, ASTNode inNode, int position) {
// if (node instanceof RutaStatement) {
// RutaStatement statement = (RutaStatement) node;
// List expressions = statement.getExpressions();
// int len = expressions.size();
// boolean first = false;
// String completionToken = null;
// ASTNode completionNode = null;
// for (int i = 0; i < len; ++i) {
// ASTNode n = (ASTNode) expressions.get(i);
// if (n.sourceStart() <= position && n.sourceEnd() >= position
// || (node instanceof RutaEmptyCompleteStatement)) {
// if (i == 0) {
// first = true;
// }
// completionNode = n;
// }
// }
// if (completionNode == null) {
// // TODO: Add inner completion here.
// if (len > 0) {
// // ASTNode firstNode = (ASTNode) expressions.get(0);
// // if (position > firstNode.sourceEnd()) {
// // // This could be variable completion.
// // boolean provideDollar =
// // !checkVariableWithoutDollarCompletion(
// // statement, position);
// // this.assistNodeParent = inNode;
// // SimpleReference ref = new SimpleReference(position,
// // position, "");
// // ASTNode nde = new CompletionOnVariable("", ref, node,
// // inNode, true, provideDollar);
// // throw new CompletionNodeFound(nde, null);
// // }
// String[] keywords = checkKeywords(completionToken, MODULE);
// ASTNode nde = new CompletionOnKeywordArgumentOrFunctionArgument("",
// (RutaStatement) node, keywords, position);
// this.assistNodeParent = inNode;
// throw new CompletionNodeFound(nde, null/* ((TypeDeclaration)inNode).scope */);
//
// } else {
// completionToken = "";
// }
// } else if (completionNode instanceof SimpleReference) {
// int maxLen = position - completionNode.sourceStart();
// completionToken = ((SimpleReference) completionNode).getName();
// // We need to cut some sumbols if node is begger then position.
// if (completionToken.length() > maxLen && maxLen > 0) {
// completionToken = completionToken.substring(0, maxLen);
// }
// } /*
// * else if (completionNode instanceof RutaBlockExpression) { RutaBlockExpression
// * block = (RutaBlockExpression) completionNode;
// *
// * List s = block.parseBlock(); if (s != null) { int slen = s.size(); for (int u = 0; u <
// * slen; ++u) { ASTNode n = (ASTNode) s.get(u); n.setStart(n.sourceStart() -
// * block.sourceStart()); n.setEnd(n.sourceEnd() - block.sourceStart());
// * RutaASTUtil.extendStatement(n, block.getBlock()); n.setStart(n.sourceStart() +
// * block.sourceStart()); n.setEnd(n.sourceEnd() + block.sourceStart()); if (n != null &&
// * n.sourceStart() <= position && n.sourceEnd() >= position) { parseBlockStatements(n,
// * inNode, position); } } } handleNotInElement(inNode, position); }
// */
// if (completionNode instanceof StringLiteral) {
// int maxLen = position - completionNode.sourceStart();
// int pos = maxLen;
// SimpleReference tok = RutaParseUtils.extractVariableFromString(
// (StringLiteral) completionNode, pos);
// if (tok != null) {
// this.assistNodeParent = inNode;
// ASTNode nde = new CompletionOnVariable(tok.getName(), tok, node, inNode, false);
// throw new CompletionNodeFound(nde, null);
// } else {
// this.assistNodeParent = inNode;
// SimpleReference ref = new SimpleReference(position, position, "");
// ASTNode nde = new CompletionOnVariable("", ref, node, inNode, true);
// throw new CompletionNodeFound(nde, null);
// }
// }
// // if (completionNode instanceof RutaExecuteExpression) {
// // RutaExecuteExpression expr = (RutaExecuteExpression)
// // completionNode;
// // List exprs = expr.parseExpression();
// // for (int i = 0; i < exprs.size(); ++i) {
// // ASTNode n = (ASTNode) exprs.get(i);
// // if (n.sourceStart() <= position
// // && n.sourceEnd() >= position) {
// // parseBlockStatements(n, expr, position);
// // }
// // }
// // handleNotInElement(expr, position);
// // }
// if (completionToken != null && completionToken.startsWith("$")) {
// // Argument name completion...
// this.assistNodeParent = inNode;
// ASTNode nde = new CompletionOnVariable(completionToken, completionNode, node, inNode, false);
// throw new CompletionNodeFound(nde, null);
// } else {
// // This is keyword or function completion.
// if (inNode instanceof ModuleDeclaration && completionNode != null && first) {
// String[] keywords = checkKeywords(completionToken, MODULE);
// ASTNode nde = new CompletionOnKeywordOrFunction(completionToken, completionNode, node,
// keywords);
// this.assistNodeParent = inNode;
// throw new CompletionNodeFound(nde, ((ModuleDeclaration) inNode).scope);
// } else if (inNode instanceof MethodDeclaration && completionNode != null && first) {
// String[] keywords = checkKeywords(completionToken, FUNCTION);
// ASTNode nde = new CompletionOnKeywordOrFunction(completionToken, completionNode, node,
// keywords);
// this.assistNodeParent = inNode;
// throw new CompletionNodeFound(nde, ((MethodDeclaration) inNode).scope);
// } else if (inNode instanceof TypeDeclaration && completionNode != null && first) {
// String[] keywords = checkKeywords(completionToken, NAMESPACE);
// ASTNode nde = new CompletionOnKeywordOrFunction(completionToken, completionNode, node,
// keywords);
// this.assistNodeParent = inNode;
// throw new CompletionNodeFound(nde, null/* ((TypeDeclaration)inNode).scope */);
// // } else if (inNode instanceof RutaExecuteExpression
// // && completionNode != null && first) {
// // String[] keywords = checkKeywords(completionToken,
// // EXEC_EXPRESSION);
// // ASTNode nde = new CompletionOnKeywordOrFunction(
// // completionToken, completionNode, node, keywords);
// // this.assistNodeParent = inNode;
// // throw new CompletionNodeFound(nde, null/*
// // ((TypeDeclaration)inNode).scope */);
// } else {
// if (completionNode != null) {
// String[] keywords = checkKeywords(completionToken, MODULE);
//
// ASTNode nde = new CompletionOnKeywordArgumentOrFunctionArgument(completionToken,
// completionNode, (RutaStatement) node, keywords);
// this.assistNodeParent = inNode;
// throw new CompletionNodeFound(nde, null/* ((TypeDeclaration)inNode).scope */);
// } else {
// String[] keywords = checkKeywords(completionToken, MODULE);
// if (completionToken == null) {
// completionToken = "";
// }
// ASTNode nde = new CompletionOnKeywordArgumentOrFunctionArgument(completionToken,
// (RutaStatement) node, keywords, position);
// this.assistNodeParent = inNode;
// throw new CompletionNodeFound(nde, null/* ((TypeDeclaration)inNode).scope */);
// }
// }
// }
// // if (checkVariableWithoutDollarCompletion(statement, position)
// // && completionToken != null) {
// // this.assistNodeParent = inNode;
// // SimpleReference ref = new SimpleReference(completionNode
// // .sourceStart(), completionNode.sourceEnd(),
// // completionToken);
// // ASTNode nde = new CompletionOnVariable(completionToken, ref,
// // node, inNode, true);
// // throw new CompletionNodeFound(nde, null);
// // }
//
// } else if (node instanceof MethodDeclaration) {
// MethodDeclaration method = (MethodDeclaration) node;
// List statements = method.getStatements();
// boolean inStatement = false;
// if (statements != null) {
// int length = statements.size();
// for (int i = 0; i < length; i++) {
// ASTNode nde = (ASTNode) statements.get(i);
// if (nde.sourceStart() <= position && nde.sourceEnd() >= position) {
// inStatement = true;
// parseBlockStatements(nde, method, position);
// }
// }
// }
// if (!inStatement) {
// this.handleNotInElement(method, position);
// }
// } else {
// visitElements(node, position);
// }
}
public class CompletionVisitor extends ASTVisitor {
protected int position;
protected ModuleDeclaration module;
public CompletionVisitor(int position, ModuleDeclaration module) {
this.position = position;
this.module = module;
}
@Override
public boolean visit(Statement s) throws Exception {
// if (s.sourceStart() <= position && s.sourceEnd() >= position) {
// for (int i = 0; i < extensions.length; i++) {
// extensions[i].visit(s, RutaCompletionParser.this,
// position);
// }
// if (s instanceof RutaStatement) {
// ASTNode inNode = RutaParseUtil.getScopeParent(module, s);
// RutaCompletionParser.this.parseBlockStatements(s, inNode,
// position);
// }
// if (s instanceof RutaPackageDeclaration) {
// RutaPackageDeclaration decl =
// (RutaPackageDeclaration) s;
// if (decl.getNameStart() <= position
// && position <= decl.getNameEnd()) {
// ASTNode inNode = RutaParseUtil.getScopeParent(module, s);
// assistNodeParent = inNode;
// throw new CompletionNodeFound(decl, null/*
// ((TypeDeclaration)inNode).scope */);
// }
// }
// }
return super.visit(s);
}
@Override
public boolean visit(Expression s) throws Exception {
if (s.sourceStart() <= position && s.sourceEnd() >= position) {
for (int i = 0; i < extensions.length; i++) {
extensions[i].visit(s, RutaCompletionParser.this, position);
}
}
return super.visit(s);
}
@Override
public boolean endvisit(Expression s) throws Exception {
if (s instanceof Block && s.sourceStart() <= position && s.sourceEnd() >= position) {
// We are in block, and no in node completion are done.
String[] keywords = checkKeywords("", MODULE);
ASTNode inNode = RutaParseUtils.getScopeParent(module, s);
ASTNode nde = new CompletionOnKeywordOrFunction("", inNode, s, keywords);
assistNodeParent = inNode;
throw new CompletionNodeFound(nde, null);
}
return super.endvisit(s);
}
};
protected CompletionVisitor createCompletionVisitor(int position) {
return new CompletionVisitor(position, this.getModule());
}
private void visitElements(ASTNode node, int position) {
if (!(node instanceof RutaStatement)) {
CompletionVisitor visitor = createCompletionVisitor(position);
try {
node.traverse(visitor);
} catch (CompletionNodeFound e) {
throw e;
} catch (Exception e) {
e.printStackTrace();
}
}
}
private boolean checkVariableWithoutDollarCompletion(RutaStatement statement, int position) {
// TODO: Add more compecated check.
Expression e = statement.getAt(0);
if (e instanceof SimpleReference) {
SimpleReference ref = (SimpleReference) e;
String name = ref.getName();
if (name.equals("set")) {
return true;
}
}
return false;
}
public String[] checkKeywords(String completionToken, int type) {
// String[] keywords = RutaKeywordsManager.getKeywords(type);
// // TODO: Possible require cases.
// if (type == MODULE || type == FUNCTION || type == NAMESPACE
// || type == EXEC_EXPRESSION) {
// // Suppose we can handle all keywords.
// String[] kw = new String[keywords.length];
// for (int i = 0; i < keywords.length; ++i) {
// kw[i] = keywords[i];
// }
// return kw;
// }
return null;
}
public void setAssistNodeParent(ASTNode prevParent) {
this.assistNodeParent = prevParent;
}
public ModuleDeclaration parse(IModuleSource sourceModule) {
ModuleDeclaration module = (ModuleDeclaration) this.parser.parse(sourceModule, null);
module.rebuild();
return module;
}
}