use of org.metaborg.core.language.ILanguageComponent in project spoofax by metaborg.
the class JSGLRCompletionService method completionEmptyProgram.
public Collection<? extends ICompletion> completionEmptyProgram(Iterable<String> startSymbols, int endOffset, ILanguageImpl language, FileObject location) throws MetaborgException {
Collection<ICompletion> completions = Lists.newLinkedList();
final String languageName = language.belongsTo().name();
for (ILanguageComponent component : language.components()) {
// 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 (String startSymbol : startSymbols) {
String placeholderName = startSymbol + "-Plhdr";
IStrategoAppl placeholder = termFactory.makeAppl(termFactory.makeConstructor(placeholderName, 0));
IStrategoTuple input = termFactory.makeTuple(termFactory.makeString(startSymbol), placeholder);
final IStrategoTerm proposalsPlaceholder = strategoCommon.invoke(runtime, input, "get-proposals-empty-program-" + languageName);
if (proposalsPlaceholder == null) {
logger.error("Getting proposals for {} failed", placeholder);
continue;
}
for (IStrategoTerm proposalTerm : proposalsPlaceholder) {
if (!(proposalTerm instanceof IStrategoTuple)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final IStrategoTuple tuple = (IStrategoTuple) proposalTerm;
if (tuple.getSubtermCount() != 2 || !(tuple.getSubterm(0) instanceof IStrategoString) || !(tuple.getSubterm(1) 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(1));
completions.add(new Completion(name, startSymbol, text, additionalInfo, 0, endOffset, CompletionKind.expansion));
}
}
}
return completions;
}
use of org.metaborg.core.language.ILanguageComponent in project spoofax by metaborg.
the class JSGLRCompletionService method completionErroneousPrograms.
public Collection<ICompletion> completionErroneousPrograms(int cursorPosition, Iterable<IStrategoTerm> completionTerms, ISpoofaxParseUnit completionParseResult) throws MetaborgException {
final FileObject location = completionParseResult.source();
final ILanguageImpl language = completionParseResult.input().langImpl();
final String languageName = language.belongsTo().name();
final Collection<ICompletion> completions = Lists.newLinkedList();
final Collection<IStrategoTerm> proposalsTerm = Lists.newLinkedList();
for (ILanguageComponent component : language.components()) {
final ITermFactory termFactory = termFactoryService.get(component, null, false);
for (IStrategoTerm completionTerm : completionTerms) {
IStrategoTerm completionAst = completionParseResult.ast();
final StrategoTerm topMostAmb = findTopMostAmbNode((StrategoTerm) completionTerm);
if (ImploderAttachment.get(completionTerm).isSinglePlaceholderCompletion()) {
Collection<IStrategoTerm> placeholders = Lists.newLinkedList();
placeholders.addAll(findPlaceholderTerms(completionTerm));
if (placeholders.size() != 1) {
logger.error("Getting proposals for {} failed", completionTerm);
continue;
}
IStrategoAppl placeholderTerm = (IStrategoAppl) Iterables.get(placeholders, 0);
IStrategoAppl placeholder = termFactory.makeAppl(termFactory.makeConstructor(placeholderTerm.getConstructor().getName(), 0));
IStrategoTerm parenthesized = parenthesizeTerm(completionTerm, termFactory);
final IStrategoTerm inputStratego = termFactory.makeTuple(termFactory.makeString(ImploderAttachment.getElementSort(parenthesized)), completionAst, completionTerm, topMostAmb, parenthesized, placeholder, placeholderTerm);
final HybridInterpreter runtime = strategoRuntimeService.runtime(component, location, false);
final IStrategoTerm proposalTerm = strategoCommon.invoke(runtime, inputStratego, "get-proposals-incorrect-programs-single-placeholder-" + languageName);
if (proposalTerm == null || !(proposalTerm instanceof IStrategoList)) {
logger.error("Getting proposals for {} failed", completionTerm);
continue;
}
for (IStrategoTerm proposalPlaceholder : proposalTerm) {
proposalsTerm.add(proposalPlaceholder);
}
} else {
IStrategoTerm parenthesized = parenthesizeTerm(completionTerm, termFactory);
final IStrategoTerm inputStratego = termFactory.makeTuple(termFactory.makeString(ImploderAttachment.getElementSort(parenthesized)), completionAst, completionTerm, topMostAmb, parenthesized);
final HybridInterpreter runtime = strategoRuntimeService.runtime(component, location, false);
final IStrategoTerm proposalTerm = strategoCommon.invoke(runtime, inputStratego, "get-proposals-incorrect-programs-" + languageName);
if (proposalTerm == null) {
logger.error("Getting proposals for {} failed", completionTerm);
continue;
}
proposalsTerm.add(proposalTerm);
}
}
for (IStrategoTerm proposalTerm : proposalsTerm) {
if (!(proposalTerm instanceof IStrategoTuple)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final IStrategoTuple tuple = (IStrategoTuple) proposalTerm;
if (tuple.getSubtermCount() != 6 || !(tuple.getSubterm(0) instanceof IStrategoString) || !(tuple.getSubterm(1) instanceof IStrategoString) || !(tuple.getSubterm(2) instanceof IStrategoString) || !(tuple.getSubterm(3) instanceof IStrategoAppl) || (tuple.getSubterm(4) == null) || !(tuple.getSubterm(5) instanceof IStrategoString)) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
final String name = Tools.asJavaString(tuple.getSubterm(0));
String text = Tools.asJavaString(tuple.getSubterm(1));
String additionalInfo = Tools.asJavaString(tuple.getSubterm(2));
final StrategoAppl change = (StrategoAppl) tuple.getSubterm(3);
final StrategoTerm completionTerm = (StrategoTerm) tuple.getSubterm(4);
final String completionKind = Tools.asJavaString(tuple.getSubterm(5));
String prefix = calculatePrefix(cursorPosition, completionTerm);
String suffix = calculateSuffix(cursorPosition, completionTerm);
// if the change is inserting at the end of a list
if (change.getConstructor().getName().contains("INSERT_AT_END")) {
// calls a different method because now, the program has errors that should be fixed
final ICompletion completion = createCompletionInsertAtEndFixing(name, text, additionalInfo, prefix, suffix, change, completionKind);
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 = createCompletionInsertBeforeFixing(name, text, additionalInfo, prefix, suffix, change, completionKind);
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
} else if (change.getConstructor().getName().contains("INSERTION_TERM")) {
final ICompletion completion = createCompletionInsertionTermFixing(name, text, additionalInfo, prefix, suffix, change, completionKind);
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
} else if (change.getConstructor().getName().contains("REPLACE_TERM")) {
final ICompletion completion = createCompletionReplaceTermFixing(name, text, additionalInfo, prefix, suffix, change, completionKind);
if (completion == null) {
logger.error("Unexpected proposal term {}, skipping", proposalTerm);
continue;
}
completions.add(completion);
}
}
}
return completions;
}
use of org.metaborg.core.language.ILanguageComponent in project spoofax by metaborg.
the class TermFactoryService method getTypesmartContext.
private TypesmartContext getTypesmartContext(ILanguageComponent component) {
TypesmartContext context = mergedTypesmartContexts.get(component);
if (context == null) {
FileObject localContextFile = new SpoofaxCommonPaths(component.location()).strTypesmartExportedFile();
context = TypesmartContext.load(localContextFile, typesmartLogger);
try {
for (ILanguageComponent other : dependencyService.sourceDeps(component)) {
FileObject otherContextFile = new SpoofaxCommonPaths(other.location()).strTypesmartExportedFile();
TypesmartContext otherContext = TypesmartContext.load(otherContextFile, typesmartLogger);
context = context.merge(otherContext);
}
} catch (MissingDependencyException e) {
typesmartLogger.error("Could not load source dependencies of " + component + " to resolve typesmart contexts.", e);
}
mergedTypesmartContexts.put(component, context);
}
return context;
}
use of org.metaborg.core.language.ILanguageComponent in project spoofax by metaborg.
the class ResolverService method resolve.
@Override
public Resolution resolve(int offset, ISpoofaxParseUnit result) throws MetaborgException {
if (!result.valid()) {
return null;
}
final FileObject source = result.source();
final IProject project = projectService.get(source);
final ILanguageImpl langImpl = result.input().langImpl();
@Nullable IContext context;
if (project == null) {
context = null;
} else {
try {
context = contextService.get(source, project, langImpl);
} catch (ContextException | MetaborgRuntimeException e) {
// Failed to get a context, ignore and use the source file to get a stratego runtime later.
context = null;
}
}
final FacetContribution<ResolverFacet> facetContrib = facet(langImpl);
final ResolverFacet facet = facetContrib.facet;
final ILanguageComponent contributor = facetContrib.contributor;
final String strategy = facet.strategyName;
try {
final ITermFactory termFactory = termFactoryService.get(contributor, project, true);
final HybridInterpreter interpreter;
if (context == null) {
interpreter = strategoRuntimeService.runtime(contributor, source, true);
} else {
interpreter = strategoRuntimeService.runtime(contributor, context, true);
}
final Iterable<IStrategoTerm> inRegion = tracingService.fragments(result, new SourceRegion(offset));
final TermWithRegion tuple = common.outputs(termFactory, interpreter, source, source, result.ast(), inRegion, strategy);
return resolve(tuple);
} catch (MetaborgException e) {
throw new MetaborgException("Reference resolution failed", e);
}
}
use of org.metaborg.core.language.ILanguageComponent in project spoofax by metaborg.
the class StrategoTransformer method transform.
private <I extends IUnit> ISpoofaxTransformUnit<I> transform(I input, IContext context, TransformActionContrib actionContribution, FileObject source, IStrategoTerm term, ITransformConfig config) throws TransformException {
final FileObject location = context.location();
final ILanguageComponent component = actionContribution.contributor;
final TransformAction action = action(actionContribution.action);
// Get input term
final IStrategoTerm inputTerm = common.builderInputTerm(term, source, location);
// Get Stratego runtime
final HybridInterpreter runtime;
try {
runtime = strategoRuntimeService.runtime(component, context, true);
} catch (MetaborgException e) {
throw new TransformException("Transformation failed unexpectedly; cannot get Stratego interpreter", e);
}
// Transform
logger.debug("Transforming {} with '{}'", source, action.name);
final Timer timer = new Timer(true);
final IStrategoTerm outputTerm;
try {
outputTerm = common.invoke(runtime, inputTerm, action.strategy);
} catch (MetaborgException e) {
throw new TransformException(e.getMessage(), e.getCause());
}
final long duration = timer.stop();
if (outputTerm == null) {
final String message = logger.format("Invoking Stratego strategy {} failed", action.strategy);
throw new TransformException(message);
}
// Get the result and, if allowed and required, write to file
List<TransformOutput> outputs;
IStrategoTerm resultTerm;
if (outputTerm.getSubtermCount() == 2 && (outputTerm instanceof IStrategoTuple)) {
final IStrategoTerm resourceTerm = outputTerm.getSubterm(0);
final IStrategoTerm contentTerm = outputTerm.getSubterm(1);
try {
if (resourceTerm instanceof IStrategoString) {
resultTerm = contentTerm;
outputs = Lists.newArrayList(output(resourceTerm, contentTerm, location, config));
} else if (resourceTerm instanceof IStrategoList) {
if (!(contentTerm instanceof IStrategoList) || resourceTerm.getSubtermCount() != contentTerm.getSubtermCount()) {
logger.error("List of terms does not match list of file names, cannot write to file.");
resultTerm = null;
outputs = Collections.emptyList();
} else {
outputs = Lists.newArrayListWithExpectedSize(resourceTerm.getSubtermCount());
for (int i = 0; i < resourceTerm.getSubtermCount(); i++) {
outputs.add(output(resourceTerm.getSubterm(i), contentTerm.getSubterm(i), location, config));
}
resultTerm = resourceTerm.getSubtermCount() == 1 ? resourceTerm.getSubterm(0) : null;
}
} else {
logger.error("First term of result tuple {} is neither a string, nor a list, cannot write output file", resourceTerm);
resultTerm = null;
outputs = Collections.emptyList();
}
} catch (MetaborgException ex) {
resultTerm = null;
outputs = Collections.emptyList();
}
} else {
resultTerm = outputTerm;
outputs = Collections.emptyList();
}
// Open editor
if (action.flags.openEditor) {
List<FileObject> resources = Lists.newArrayListWithExpectedSize(outputs.size());
for (TransformOutput output : outputs) {
if (output.resource != null) {
resources.add(output.resource);
}
}
editorRegistry.open(resources, context.project());
}
// Return result
final TransformContrib contrib = new TransformContrib(resultTerm != null || !Iterables.isEmpty(outputs), true, resultTerm, outputs, Iterables2.<IMessage>empty(), duration);
return unitService.transformUnit(input, contrib, context, actionContribution);
}
Aggregations