Examples with Paths mb.nabl2.scopegraph.terms.path.Paths used on opensource projects

Example 1 with Paths

use of mb.nabl2.scopegraph.terms.path.Paths 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());
}

Example 2 with Paths

use of mb.nabl2.scopegraph.terms.path.Paths in project nabl by metaborg.

the class NameResolutionTerms method buildRef.

private ITerm buildRef(Occurrence ref) {
    final List<ITerm> paths = nameResolution.resolve(ref).orElseGet(() -> Set.Immutable.of()).stream().map(this::buildPath).collect(Collectors.toList());
    final ITerm result;
    if (paths.isEmpty()) {
        result = B.newAppl("NoResolution");
    } else {
        result = B.newAppl("Resolution", (ITerm) B.newList(paths));
    }
    return B.newTuple(ref, result);
}

Example 3 with Paths

use of mb.nabl2.scopegraph.terms.path.Paths 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));
}

Example 4 with Paths

use of mb.nabl2.scopegraph.terms.path.Paths in project nabl by metaborg.

the class SG_get_ref_resolution method call.

@Override
public Optional<? extends ITerm> call(IScopeGraphUnit unit, ITerm term, List<ITerm> terms) throws InterpreterException {
    return unit.solution().flatMap(s -> {
        return Occurrence.matcher().match(term, s.unifier()).<ITerm>flatMap(ref -> {
            return s.nameResolution().resolve(ref).map(paths -> {
                List<ITerm> pathTerms = Lists.newArrayListWithExpectedSize(paths.size());
                for (IResolutionPath<Scope, Label, Occurrence> path : paths) {
                    pathTerms.add(B.newTuple(path.getDeclaration(), Paths.toTerm(path)));
                }
                ITerm result = B.newList(pathTerms);
                return result;
            });
        });
    });
}