use of mb.nabl2.scopegraph.terms.Label in project nabl by metaborg.
the class InterpreterTerms method scopeEntries.
private static ITerm scopeEntries(IScopeGraph<Scope, Label, Occurrence> scopeGraph) {
Map<ITerm, ITerm> entries = Maps.newHashMap();
for (Scope scope : scopeGraph.getAllScopes()) {
IListTerm decls = B.newList(scopeGraph.getDecls().inverse().get(scope));
IListTerm refs = B.newList(scopeGraph.getRefs().inverse().get(scope));
IListTerm edges = multimap(scopeGraph.getDirectEdges().get(scope));
IListTerm imports = multimap(scopeGraph.getImportEdges().get(scope));
ITerm entry = B.newAppl("SE", decls, refs, edges, imports);
entries.put(scope, entry);
}
return map(entries.entrySet());
}
use of mb.nabl2.scopegraph.terms.Label in project nabl by metaborg.
the class InterpreterTerms method refEntries.
private static ITerm refEntries(IScopeGraph<Scope, Label, Occurrence> scopeGraph) {
Map<ITerm, ITerm> entries = Maps.newHashMap();
for (Occurrence ref : scopeGraph.getAllRefs()) {
ITerm scope = scopeGraph.getRefs().get(ref).map(s -> B.newList(s)).orElse(B.newNil());
ITerm entry = B.newAppl("RE", scope);
entries.put(ref, entry);
}
return map(entries.entrySet());
}
use of mb.nabl2.scopegraph.terms.Label in project nabl by metaborg.
the class InterpreterTerms method nameresolution.
private static ITerm nameresolution(IEsopNameResolution<Scope, Label, Occurrence> nameResolution) {
nameResolution.resolveAll();
final Map<ITerm, ITerm> entries = Maps.newHashMap();
for (Map.Entry<Occurrence, Set<IResolutionPath<Scope, Label, Occurrence>>> entry : nameResolution.resolutionEntries()) {
final Occurrence ref = entry.getKey();
final Set<IResolutionPath<Scope, Label, Occurrence>> paths = entry.getValue();
if (paths.size() == 1) {
IResolutionPath<Scope, Label, Occurrence> path = Iterables.getOnlyElement(paths);
ITerm value = B.newTuple(path.getDeclaration(), Paths.toTerm(path));
entries.put(ref, value);
} else {
logger.warn("Can only convert a single path, but {} has {}.", ref, paths.size());
}
}
return map(entries.entrySet());
}
use of mb.nabl2.scopegraph.terms.Label in project nabl by metaborg.
the class InterpreterTerms method declEntries.
private static ITerm declEntries(IScopeGraph<Scope, Label, Occurrence> scopeGraph) {
Map<ITerm, ITerm> entries = Maps.newHashMap();
for (Occurrence decl : scopeGraph.getAllDecls()) {
ITerm scope = scopeGraph.getDecls().get(decl).map(s -> B.newList(s)).orElse(B.newNil());
ITerm assocs = multimap(scopeGraph.getExportEdges().get(decl));
ITerm entry = B.newAppl("DE", scope, assocs);
entries.put(decl, entry);
}
return map(entries.entrySet());
}
use of mb.nabl2.scopegraph.terms.Label in project nabl by metaborg.
the class NameResolutionComponent method solve.
// ------------------------------------------------------------------------------------------------------//
private Optional<SolveResult> solve(CResolve r) {
final ITerm refTerm = unifier().findRecursive(r.getReference());
if (!refTerm.isGround()) {
return Optional.empty();
}
final Occurrence ref = Occurrence.matcher().match(refTerm, unifier()).orElseThrow(() -> new TypeException("Expected an occurrence as first argument to " + r));
final Optional<java.util.Set<IResolutionPath<Scope, Label, Occurrence>>> maybePathsAndDeps = nameResolution.resolve(ref);
if (!maybePathsAndDeps.isPresent()) {
return Optional.empty();
}
final java.util.Set<IResolutionPath<Scope, Label, Occurrence>> paths = maybePathsAndDeps.get();
final List<Occurrence> declarations = Paths.resolutionPathsToDecls(paths);
final Multimap<String, String> deps = HashMultimap.create();
deps.putAll(ref.getIndex().getResource(), declarations.stream().map(d -> d.getIndex().getResource()).collect(Collectors.toSet()));
final SolveResult result;
switch(declarations.size()) {
case 0:
{
IMessageInfo message = r.getMessageInfo().withDefaultContent(MessageContent.builder().append(ref).append(" does not resolve.").build());
result = SolveResult.messages(message);
break;
}
case 1:
{
final Occurrence decl = declarations.get(0);
result = SolveResult.constraints(ImmutableCEqual.of(r.getDeclaration(), decl, r.getMessageInfo()));
break;
}
default:
{
IMessageInfo message = r.getMessageInfo().withDefaultContent(MessageContent.builder().append("Resolution of ").append(ref).append(" is ambiguous.").build());
result = SolveResult.messages(message);
break;
}
}
return Optional.of(ImmutableSolveResult.copyOf(result).withDependencies(deps));
}
Aggregations