public Collection<? extends PDefinition> getDefinitions(PMultipleBind mb, PType type, TypeCheckInfo question) { List<PDefinition> defs = new Vector<PDefinition>(); for (PPattern p : mb.getPlist()) { defs.addAll(af.createPPatternAssistant().getDefinitions(p, type, question.scope)); } return defs; }
public PType getPossibleType(LinkedList<PPattern> plist, ILexLocation location) { switch (plist.size()) { case 0: return AstFactory.newAUnknownType(location); case 1: return af.createPPatternAssistant().getPossibleType(plist.get(0)); default: PTypeSet list = new PTypeSet(af); for (PPattern p : plist) { list.add(af.createPPatternAssistant().getPossibleType(p)); } return list.getType(location); // NB. a union of types } }
public boolean isSimple(LinkedList<PPattern> p) { for (PPattern pattern : p) { if (!af.createPPatternAssistant().isSimple(pattern)) { return false; // NB. AND } } return true; }
public boolean alwaysMatches(PPattern pattern, PType type) { return af.getTypeComparator().isSubType(getPossibleType(pattern), type) && alwaysMatches(pattern); } }
@Override public PType caseAForAllStm(AForAllStm node, TypeCheckInfo question) throws AnalysisException { node.setType(node.getSet().apply(THIS, question)); question.assistantFactory.createPPatternAssistant().typeResolve(node.getPattern(), THIS, question); if (question.assistantFactory.createPTypeAssistant().isSet(node.getType())) { SSetType st = question.assistantFactory.createPTypeAssistant().getSet(node.getType()); List<PDefinition> defs = question.assistantFactory.createPPatternAssistant().getDefinitions(node.getPattern(), st.getSetof(), NameScope.LOCAL); Environment local = new FlatCheckedEnvironment(question.assistantFactory, defs, question.env, question.scope); PType rt = node.getStatement().apply(THIS, new TypeCheckInfo(question.assistantFactory, local, question.scope)); local.unusedCheck(); node.setType(rt); return rt; } else { TypeCheckerErrors.report(3219, "For all statement does not contain a set type", node.getLocation(), node); node.setType(AstFactory.newAUnknownType(node.getLocation())); return node.getType(); } }
@Override public void caseAForAllStm(AForAllStm node) throws AnalysisException { if (!proceed(node)) { return; } if (node.getSet() != null) { node.getSet().apply(this); } PType possibleType = af.createPPatternAssistant().getPossibleType(node.getPattern()); List<PDefinition> defs = af.createPPatternAssistant().getDefinitions(node.getPattern(), possibleType, NameScope.LOCAL); for (PDefinition d : defs) { openLoop(d.getName(), node.getPattern(), node.getStatement()); } node.getStatement().apply(this); for (PDefinition def : defs) { removeLocalDefFromScope(def); } }
question.assistantFactory.createPPatternAssistant().typeResolve(c.getPattern(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env)); question.assistantFactory.createPPatternAssistant().typeResolve(c.getPattern(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env)); c.getDefs().addAll(question.assistantFactory.createPPatternAssistant().getDefinitions(c.getPattern(), expType, NameScope.LOCAL)); } catch (TypeCheckException e) question.assistantFactory.createPPatternAssistant().typeCheck(c.getPattern(), question, rootVisitor); question.assistantFactory.createPDefinitionListAssistant().typeCheck(c.getDefs(), rootVisitor, new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); if (!question.assistantFactory.createPPatternAssistant().matches(c.getPattern(), expType))
question.assistantFactory.createPPatternAssistant().typeResolve(node.getPattern(), THIS, question); question.assistantFactory.createPPatternAssistant().typeResolve(node.getPattern(), THIS, question); node.getDefs().addAll(question.assistantFactory.createPPatternAssistant().getDefinitions(node.getPattern(), stm.getExp().getType(), NameScope.LOCAL)); if (!question.assistantFactory.createPPatternAssistant().matches(node.getPattern(), node.getCtype()))
public boolean alwaysMatches(List<PPattern> pl) { for (PPattern p : pl) { if (!af.createPPatternAssistant().alwaysMatches(p)) { return false; // NB. AND } } return true; }
@Override public LexNameList caseAValueDefinition(AValueDefinition node) throws AnalysisException { return af.createPPatternAssistant().getVariableNames(node.getPattern()); }
ILexNameToken origName = af.createPPatternAssistant().getAllVariableNames(orig).get(0).clone(); PExp new_exp = args.get(0).clone(); subs.add(new Substitution(origName, new_exp));
@Override public PPatternAssistantTC createPPatternAssistant() { return new PPatternAssistantTC(this); }
/** * Get a set of definitions for the pattern's variables. Note that if the pattern includes duplicate variable names, * these are collapse into one. * * @param rp * @param ptype * @param scope * @return */ public List<PDefinition> getDefinitions(PPattern rp, PType ptype, NameScope scope) { PDefinitionSet set = af.createPDefinitionSet(); set.addAll(af.createPPatternAssistant().getAllDefinitions(rp, ptype, scope)); List<PDefinition> result = new Vector<PDefinition>(set); return result; }
question.assistantFactory.createPPatternAssistant().typeResolve(node.getPattern(), THIS, question); node.setDefs(question.assistantFactory.createPPatternAssistant().getDefinitions(node.getPattern(), type, NameScope.LOCAL));
@Override public Boolean caseAConcatenationPattern(AConcatenationPattern node) throws AnalysisException { return af.createPPatternAssistant().alwaysMatches(node.getLeft()) && af.createPPatternAssistant().alwaysMatches(node.getRight()); }
question.assistantFactory.createPPatternAssistant().getVariableNames(node.getSetBind().getPattern()).size() > 1 || !question.assistantFactory.createPTypeAssistant().isOrdered(question.assistantFactory.createPDefinitionAssistant().getType(def), node.getLocation())))
public OperationCallObligation(ACallStm stm, SOperationDefinitionBase def, IPOContextStack ctxt, IPogAssistantFactory af) throws AnalysisException { super(stm, POType.OP_CALL, ctxt, stm.getLocation(), af); // cannot quote pre-cond so we spell it out with rewritten arguments List<Substitution> subs = new LinkedList<Substitution>(); for (int i = 0; i < stm.getArgs().size(); i++) { PPattern orig = def.getPredef().getParamPatternList().get(0).get(i); ILexNameToken origName = af.createPPatternAssistant().getAllVariableNames(orig).get(0).clone(); PExp new_exp = stm.getArgs().get(0); subs.add(new Substitution(origName, new_exp)); } PExp pre_exp = def.getPrecondition().clone(); for (Substitution sub : subs) { pre_exp = pre_exp.clone().apply(af.getVarSubVisitor(), sub); } stitch = pre_exp; valuetree.setPredicate(ctxt.getPredWithContext(pre_exp)); }
@Override public List<PDefinition> caseAConcatenationPattern( AConcatenationPattern pattern, NewQuestion question) throws AnalysisException { List<PDefinition> list = af.createPPatternAssistant().getDefinitions(pattern.getLeft(), question.ptype, question.scope); list.addAll(af.createPPatternAssistant().getDefinitions(pattern.getRight(), question.ptype, question.scope)); return list; }
public boolean matches(PPattern pattern, PType expType) { return af.getTypeComparator().compatible(af.createPPatternAssistant().getPossibleType(pattern), expType); }
question.assistantFactory.createPPatternAssistant().typeResolve(pattern, THIS, question); node.setDefs(question.assistantFactory.createPPatternAssistant().getDefinitions(pattern, node.getExpType(), question.scope)); node.setDefType(node.getExpType()); node.setDefs(question.assistantFactory.createPPatternAssistant().getDefinitions(typebind.getPattern(), node.getDefType(), question.scope)); question.assistantFactory.createPPatternAssistant().typeResolve(node.getSetbind().getPattern(), THIS, question); node.setDefs(question.assistantFactory.createPPatternAssistant().getDefinitions(node.getSetbind().getPattern(), node.getDefType(), question.scope)); question.assistantFactory.createPPatternAssistant().typeResolve(node.getSeqbind().getPattern(), THIS, question); node.setDefs(question.assistantFactory.createPPatternAssistant().getDefinitions(node.getSeqbind().getPattern(), node.getDefType(), question.scope));