Examples with HybridInterpreter org.strategoxt.HybridInterpreter used on opensource projects

Example 1 with HybridInterpreter

use of org.strategoxt.HybridInterpreter in project spoofax by metaborg.

the class StrategoRuntimeService method createPrototype.

private HybridInterpreter createPrototype(ILanguageComponent component) throws MetaborgException {
    logger.debug("Creating prototype runtime for {}", component);
    final ITermFactory termFactory = termFactoryService.get(component, null, false);
    final HybridInterpreter runtime = createNew(termFactory);
    loadFiles(runtime, component);
    prototypes.put(component, runtime);
    return runtime;
}

Example 2 with HybridInterpreter

use of org.strategoxt.HybridInterpreter in project spoofax by metaborg.

the class StrategoRuntimeService method runtime.

@Override
public HybridInterpreter runtime(ILanguageComponent component, IContext context, boolean typesmart) throws MetaborgException {
    HybridInterpreter prototype = prototypes.get(component);
    if (prototype == null) {
        prototype = createPrototype(component);
    }
    final HybridInterpreter runtime = clone(prototype, context.location(), component, context.project(), typesmart);
    runtime.getContext().setContextObject(context);
    runtime.getCompiledContext().setContextObject(context);
    return runtime;
}

Example 3 with HybridInterpreter

use of org.strategoxt.HybridInterpreter in project spoofax by metaborg.

the class HoverService method hover.

@Override
public Hover hover(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<HoverFacet> facetContrib = facet(langImpl);
    final HoverFacet 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, context.location(), source, result.ast(), inRegion, strategy);
        return hover(tuple);
    } catch (MetaborgException e) {
        throw new MetaborgException("Getting hover tooltip information failed unexpectedly", e);
    }
}

Example 4 with HybridInterpreter

use of org.strategoxt.HybridInterpreter in project spoofax by metaborg.

the class ResolverService method resolve.

@Override
public Resolution resolve(int offset, ISpoofaxAnalyzeUnit result) throws MetaborgException {
    if (!result.valid() || !result.hasAst()) {
        return null;
    }
    final FileObject source = result.source();
    final IContext context = result.context();
    final IProject project = context.project();
    final ILanguageImpl language = context.language();
    final FacetContribution<ResolverFacet> facetContrib = facet(language);
    final ResolverFacet facet = facetContrib.facet;
    final String strategy = facet.strategyName;
    try {
        final ITermFactory termFactory = termFactoryService.get(facetContrib.contributor, project, true);
        final HybridInterpreter interpreter = strategoRuntimeService.runtime(facetContrib.contributor, context, true);
        final Iterable<IStrategoTerm> inRegion = tracingService.fragments(result, new SourceRegion(offset));
        final TermWithRegion tuple;
        try (IClosableLock lock = context.read()) {
            tuple = common.outputs(termFactory, interpreter, source, source, result.ast(), inRegion, strategy);
        }
        return resolve(tuple);
    } catch (MetaborgException e) {
        throw new MetaborgException("Reference resolution failed", e);
    }
}

Example 5 with HybridInterpreter

use of org.strategoxt.HybridInterpreter in project spoofax by metaborg.

the class AbstractConstraintAnalyzer method analyzeAll.

@SuppressWarnings("unchecked")
@Override
public ISpoofaxAnalyzeResults analyzeAll(Iterable<ISpoofaxParseUnit> inputs, IContext genericContext, IProgress progress, ICancel cancel) throws AnalysisException {
    C context;
    try {
        context = (C) genericContext;
    } catch (ClassCastException ex) {
        throw new AnalysisException(genericContext, "Scope graph context required for constraint analysis.", ex);
    }
    final ILanguageImpl langImpl = context.language();
    final FacetContribution<AnalysisFacet> facetContribution = langImpl.facetContribution(AnalysisFacet.class);
    if (facetContribution == null) {
        logger.debug("No analysis required for {}", langImpl);
        return new SpoofaxAnalyzeResults(context);
    }
    final AnalysisFacet facet = facetContribution.facet;
    final HybridInterpreter runtime;
    try {
        runtime = runtimeService.runtime(facetContribution.contributor, context, false);
    } catch (MetaborgException e) {
        throw new AnalysisException(context, "Failed to get Stratego runtime", e);
    }
    Map<String, ISpoofaxParseUnit> changed = Maps.newHashMap();
    Set<String> removed = Sets.newHashSet();
    for (ISpoofaxParseUnit input : inputs) {
        final String source;
        if (input.detached()) {
            source = "detached-" + UUID.randomUUID().toString();
        } else {
            source = resource(input.source(), context);
        }
        if (!input.valid() || isEmptyAST(input.ast())) {
            removed.add(source);
        } else {
            changed.put(source, input);
        }
    }
    return analyzeAll(changed, removed, context, runtime, facet.strategyName, progress, cancel);
}