use of org.metaborg.core.completion.ICompletion in project spoofax by metaborg.
the class JSGLRCompletionService method get.
@Override
public Iterable<ICompletion> get(int position, ISpoofaxParseUnit parseInput, boolean nested) throws MetaborgException {
ISpoofaxParseUnit completionParseResult = null;
if (!nested && !parseInput.success()) {
final JSGLRParserConfiguration config = new JSGLRParserConfiguration(true, true, true, 3000, position);
final ISpoofaxInputUnit input = parseInput.input();
final ISpoofaxInputUnit modifiedInput = unitService.inputUnit(input.source(), input.text(), input.langImpl(), input.dialect(), config);
completionParseResult = syntaxService.parse(modifiedInput);
}
Collection<ICompletion> completions = Lists.newLinkedList();
// Completion in case of empty input
String inputText = parseInput.input().text();
if (inputText.trim().isEmpty()) {
final ILanguageImpl language = parseInput.input().langImpl();
final FileObject location = parseInput.source();
final Iterable<String> startSymbols = language.facet(SyntaxFacet.class).startSymbols;
completions.addAll(completionEmptyProgram(startSymbols, inputText.length(), language, location));
return completions;
}
if (completionParseResult != null && completionParseResult.ast() == null) {
return completions;
}
Collection<IStrategoTerm> nestedCompletionTerms = getNestedCompletionTermsFromAST(completionParseResult);
Collection<IStrategoTerm> completionTerms = getCompletionTermsFromAST(completionParseResult);
boolean blankLineCompletion = isCompletionBlankLine(position, parseInput.input().text());
if (!completionTerms.isEmpty()) {
completions.addAll(completionErroneousPrograms(position, completionTerms, completionParseResult));
}
if (!nestedCompletionTerms.isEmpty()) {
completions.addAll(completionErroneousProgramsNested(position, nestedCompletionTerms, completionParseResult));
}
if (completionTerms.isEmpty() && nestedCompletionTerms.isEmpty()) {
completions.addAll(completionCorrectPrograms(position, blankLineCompletion, parseInput));
}
return completions;
}
use of org.metaborg.core.completion.ICompletion in project spoofax by metaborg.
the class JSGLRCompletionService method createCompletionInsertAtEnd.
private ICompletion createCompletionInsertAtEnd(String name, String text, String additionalInfo, StrategoAppl change, boolean blankLineCompletion) {
final StrategoTerm oldNode = (StrategoTerm) change.getSubterm(0);
final StrategoTerm newNode = (StrategoTerm) change.getSubterm(1);
// expected two lists
if (change.getSubtermCount() != 2 || !(oldNode instanceof IStrategoList) || !(newNode instanceof IStrategoList)) {
return null;
}
final String sort = ImploderAttachment.getElementSort(oldNode);
int insertionPoint, suffixPoint;
ITokens tokenizer = ImploderAttachment.getTokenizer(oldNode);
final ImploderAttachment oldListIA = oldNode.getAttachment(ImploderAttachment.TYPE);
int tokenPosition;
// node
if (oldNode.getSubtermCount() == 0) {
tokenPosition = oldListIA.getLeftToken().getIndex() - 1 > 0 ? oldListIA.getLeftToken().getIndex() - 1 : 0;
while ((tokenizer.getTokenAt(tokenPosition).getKind() == IToken.TK_LAYOUT || tokenizer.getTokenAt(tokenPosition).getKind() == IToken.TK_ERROR) && tokenPosition > 0) tokenPosition--;
insertionPoint = tokenizer.getTokenAt(tokenPosition).getEndOffset();
} else {
// if list is not empty
// insert after at end offset of the rightmost token of the element before the
// completion
StrategoTerm elementBefore = (StrategoTerm) oldNode.getSubterm(oldNode.getAllSubterms().length - 1);
int leftIdx = elementBefore.getAttachment(ImploderAttachment.TYPE).getLeftToken().getIndex();
int rightIdx = elementBefore.getAttachment(ImploderAttachment.TYPE).getRightToken().getIndex();
while ((tokenizer.getTokenAt(rightIdx).getKind() == IToken.TK_LAYOUT || tokenizer.getTokenAt(rightIdx).getLength() == 0) && rightIdx > leftIdx) {
rightIdx--;
}
insertionPoint = tokenizer.getTokenAt(rightIdx).getEndOffset();
tokenPosition = rightIdx;
}
suffixPoint = insertionPoint + 1;
// if completion is triggered in an empty line, consume that line
IToken checkToken;
boolean blankLine = false;
if (blankLineCompletion) {
for (; tokenPosition < tokenizer.getTokenCount(); tokenPosition++) {
checkToken = tokenizer.getTokenAt(tokenPosition);
if (tokenizer.toString(checkToken, checkToken).contains("\n")) {
suffixPoint = checkToken.getEndOffset();
if (!blankLine) {
blankLine = true;
} else {
break;
}
}
}
}
return new Completion(name, sort, text, additionalInfo, insertionPoint + 1, suffixPoint, CompletionKind.expansion);
}
use of org.metaborg.core.completion.ICompletion in project spoofax by metaborg.
the class JSGLRCompletionService method recursiveCompletions.
private Collection<? extends ICompletion> recursiveCompletions(Iterable<IStrategoTerm> leftRecursive, Iterable<IStrategoTerm> rightRecursive, String languageName, ILanguageComponent component, FileObject location) throws MetaborgException {
Collection<ICompletion> completions = Lists.newLinkedList();
// call Stratego part of the framework to compute change
final HybridInterpreter runtime = strategoRuntimeService.runtime(component, location, false);
final ITermFactory termFactory = termFactoryService.get(component, null, false);
for (IStrategoTerm term : leftRecursive) {
IStrategoTerm sort = termFactory.makeString(ImploderAttachment.getSort(term));
final IStrategoTerm strategoInput = termFactory.makeTuple(sort, term);
IStrategoTerm proposals = null;
try {
proposals = strategoCommon.invoke(runtime, strategoInput, "get-proposals-left-recursive-" + languageName);
} catch (Exception e) {
logger.error("Getting proposals for {} failed", term);
continue;
}
if (proposals == null) {
logger.error("Getting proposals for {} failed", term);
continue;
}
for (IStrategoTerm proposalTerm : proposals) {
final IStrategoTuple tuple = (IStrategoTuple) proposalTerm;
if (tuple.getSubtermCount() != 5 || !(tuple.getSubterm(0) instanceof IStrategoString) || !(tuple.getSubterm(1) instanceof IStrategoString) || !(tuple.getSubterm(2) instanceof IStrategoString) || !(tuple.getSubterm(3) instanceof IStrategoAppl) || !(tuple.getSubterm(4) instanceof IStrategoString)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final String name = Tools.asJavaString(tuple.getSubterm(0));
final String text = Tools.asJavaString(tuple.getSubterm(1));
final String additionalInfo = Tools.asJavaString(tuple.getSubterm(2));
final StrategoAppl change = (StrategoAppl) tuple.getSubterm(3);
final String prefix = Tools.asJavaString(tuple.getSubterm(4));
if (change.getConstructor().getName().contains("REPLACE_TERM")) {
final ICompletion completion = createCompletionReplaceTerm(name, text, additionalInfo, change, false, prefix, "");
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
}
}
}
for (IStrategoTerm term : rightRecursive) {
IStrategoTerm sort = termFactory.makeString(ImploderAttachment.getSort(term));
final IStrategoTerm strategoInput = termFactory.makeTuple(sort, term);
IStrategoTerm proposals = null;
try {
proposals = strategoCommon.invoke(runtime, strategoInput, "get-proposals-right-recursive-" + languageName);
} catch (Exception e) {
logger.error("Getting proposals for {} failed", term);
continue;
}
if (proposals == null) {
logger.error("Getting proposals for {} failed", term);
continue;
}
for (IStrategoTerm proposalTerm : proposals) {
final IStrategoTuple tuple = (IStrategoTuple) proposalTerm;
if (tuple.getSubtermCount() != 5 || !(tuple.getSubterm(0) instanceof IStrategoString) || !(tuple.getSubterm(1) instanceof IStrategoString) || !(tuple.getSubterm(2) instanceof IStrategoString) || !(tuple.getSubterm(3) instanceof IStrategoAppl) || !(tuple.getSubterm(4) instanceof IStrategoString)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final String name = Tools.asJavaString(tuple.getSubterm(0));
final String text = Tools.asJavaString(tuple.getSubterm(1));
final String additionalInfo = Tools.asJavaString(tuple.getSubterm(2));
final StrategoAppl change = (StrategoAppl) tuple.getSubterm(3);
final String suffix = Tools.asJavaString(tuple.getSubterm(4));
if (change.getConstructor().getName().contains("REPLACE_TERM")) {
final ICompletion completion = createCompletionReplaceTerm(name, text, additionalInfo, change, false, "", suffix);
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
}
}
}
return completions;
}
use of org.metaborg.core.completion.ICompletion in project spoofax by metaborg.
the class JSGLRCompletionService method listsCompletions.
public Collection<ICompletion> listsCompletions(int position, boolean blankLineCompletion, Iterable<IStrategoList> lists, String languageName, ILanguageComponent component, FileObject location) throws MetaborgException {
Collection<ICompletion> completions = Lists.newLinkedList();
final ITermFactory termFactory = termFactoryService.get(component, null, false);
for (IStrategoList list : lists) {
ListImploderAttachment attachment = list.getAttachment(null);
String sort = attachment.getSort().substring(0, attachment.getSort().length() - 1);
String placeholderName = sort + "-Plhdr";
IStrategoAppl listPlaceholder = termFactory.makeAppl(termFactory.makeConstructor(placeholderName, 0));
final IStrategoTerm strategoInput = termFactory.makeTuple(termFactory.makeString(sort), list, listPlaceholder, termFactory.makeInt(position));
final HybridInterpreter runtime = strategoRuntimeService.runtime(component, location, false);
final IStrategoTerm proposalsLists = strategoCommon.invoke(runtime, strategoInput, "get-proposals-list-" + languageName);
if (proposalsLists == null) {
logger.error("Getting proposals for {} failed", strategoInput);
continue;
}
for (IStrategoTerm proposalTerm : proposalsLists) {
if (!(proposalTerm instanceof IStrategoTuple)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final IStrategoTuple tuple = (IStrategoTuple) proposalTerm;
if (tuple.getSubtermCount() != 4 || !(tuple.getSubterm(0) instanceof IStrategoString) || !(tuple.getSubterm(1) instanceof IStrategoString) || !(tuple.getSubterm(2) instanceof IStrategoString) || !(tuple.getSubterm(3) instanceof IStrategoAppl)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final String name = Tools.asJavaString(tuple.getSubterm(0));
final String text = Tools.asJavaString(tuple.getSubterm(1));
final String additionalInfo = Tools.asJavaString(tuple.getSubterm(2));
final StrategoAppl change = (StrategoAppl) tuple.getSubterm(3);
// if the change is inserting at the end of a list
if (change.getConstructor().getName().contains("INSERT_AT_END")) {
final ICompletion completion = createCompletionInsertAtEnd(name, text, additionalInfo, change, blankLineCompletion);
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
} else if (change.getConstructor().getName().contains("INSERT_BEFORE")) {
final ICompletion completion = createCompletionInsertBefore(name, text, additionalInfo, change);
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
}
}
}
return completions;
}
use of org.metaborg.core.completion.ICompletion in project spoofax by metaborg.
the class JSGLRCompletionService method placeholderCompletions.
public Collection<ICompletion> placeholderCompletions(IStrategoAppl placeholder, String languageName, ILanguageComponent component, FileObject location) throws MetaborgException {
Collection<ICompletion> completions = Lists.newLinkedList();
// call Stratego part of the framework to compute change
final HybridInterpreter runtime = strategoRuntimeService.runtime(component, location, false);
final ITermFactory termFactory = termFactoryService.get(component, null, false);
IStrategoTerm placeholderParent = ParentAttachment.getParent(placeholder);
if (placeholderParent == null) {
placeholderParent = placeholder;
}
IStrategoInt placeholderIdx = termFactory.makeInt(-1);
for (int i = 0; i < placeholderParent.getSubtermCount(); i++) {
if (placeholderParent.getSubterm(i) == placeholder) {
placeholderIdx = termFactory.makeInt(i);
}
}
final String sort = ImploderAttachment.getSort(placeholder);
final IStrategoTerm strategoInput = termFactory.makeTuple(termFactory.makeString(sort), placeholder, placeholderParent, placeholderIdx);
final IStrategoTerm proposalsPlaceholder = strategoCommon.invoke(runtime, strategoInput, "get-proposals-placeholder-" + languageName);
if (proposalsPlaceholder == null) {
logger.error("Getting proposals for {} failed", placeholder);
return completions;
}
for (IStrategoTerm proposalTerm : proposalsPlaceholder) {
if (!(proposalTerm instanceof IStrategoTuple)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final IStrategoTuple tuple = (IStrategoTuple) proposalTerm;
if (tuple.getSubtermCount() != 4 || !(tuple.getSubterm(0) instanceof IStrategoString) || !(tuple.getSubterm(1) instanceof IStrategoString) || !(tuple.getSubterm(2) instanceof IStrategoString) || !(tuple.getSubterm(3) instanceof IStrategoAppl)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final String name = Tools.asJavaString(tuple.getSubterm(0));
final String text = Tools.asJavaString(tuple.getSubterm(1));
final String additionalInfo = Tools.asJavaString(tuple.getSubterm(2));
final StrategoAppl change = (StrategoAppl) tuple.getSubterm(3);
if (change.getConstructor().getName().contains("REPLACE_TERM")) {
final ICompletion completion = createCompletionReplaceTerm(name, text, additionalInfo, change, false, "", "");
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
}
}
return completions;
}
Aggregations