Examples with ITerm mb.nabl2.terms.ITerm used on opensource projects

Example 26 with ITerm

use of mb.nabl2.terms.ITerm in project nabl by metaborg.

the class EqualityComponent method solve.

private Optional<SolveResult> solve(CInequal constraint) {
    ITerm left = constraint.getLeft();
    ITerm right = constraint.getRight();
    if (unifier().areEqual(left, right)) {
        MessageContent content = MessageContent.builder().append(constraint.getLeft().toString()).append(" and ").append(constraint.getRight().toString()).append(" must be inequal, but are not.").build();
        IMessageInfo message = constraint.getMessageInfo().withDefaultContent(content);
        return Optional.of(SolveResult.messages(message));
    } else {
        return unifier().areUnequal(left, right) ? Optional.of(SolveResult.empty()) : Optional.empty();
    }
}

Example 27 with ITerm

use of mb.nabl2.terms.ITerm in project nabl by metaborg.

the class CNew method pp.

@Override
public IMessageContent pp() {
    final Builder builder = MessageContent.builder();
    builder.append("new ");
    boolean first = true;
    for (ITerm var : getNVars()) {
        if (first) {
            first = false;
        } else {
            builder.append(" ");
        }
        builder.append(var);
    }
    return builder.build();
}

Example 28 with ITerm

use of mb.nabl2.terms.ITerm in project nabl by metaborg.

the class SetComponent method solve.

private Optional<SolveResult> solve(CDistinct constraint) {
    ITerm setTerm = unifier().findRecursive(constraint.getSet());
    if (!setTerm.isGround()) {
        return Optional.empty();
    }
    Optional<Set<IElement<ITerm>>> maybeSet = evaluator.match(setTerm, unifier());
    if (!(maybeSet.isPresent())) {
        return Optional.empty();
    }
    Multimap<Object, IElement<ITerm>> proj = SetEvaluator.project(maybeSet.get(), constraint.getProjection());
    List<IElement<ITerm>> duplicates = Lists.newArrayList();
    for (Object key : proj.keySet()) {
        Collection<IElement<ITerm>> values = proj.get(key);
        if (values.size() > 1) {
            duplicates.addAll(values);
        }
    }
    if (duplicates.isEmpty()) {
        return Optional.of(SolveResult.empty());
    } else {
        MessageContent content = MessageContent.builder().append(B.newAppl(NAME_OP)).append(" has duplicates in ").append(setTerm).build();
        Iterable<IMessageInfo> messages = makeMessages(constraint.getMessageInfo().withDefaultContent(content), duplicates);
        return Optional.of(SolveResult.messages(messages));
    }
}

Example 29 with ITerm

use of mb.nabl2.terms.ITerm 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 30 with ITerm

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