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; }
@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; }
private List<PDefinition> getDefinitions(APatternListTypePair pltp, NameScope scope) { List<PDefinition> list = new Vector<PDefinition>(); for (PPattern p : pltp.getPatterns()) { list.addAll(af.createPPatternAssistant().getDefinitions(p, pltp.getType(), scope)); } return list; } }
public Collection<? extends PDefinition> getDefinitions( APatternListTypePair pltp, NameScope scope, ITypeCheckerAssistantFactory assistantFactory) { List<PDefinition> list = new Vector<PDefinition>(); for (PPattern p : pltp.getPatterns()) { list.addAll(assistantFactory.createPPatternAssistant().getDefinitions(p, pltp.getType(), scope)); } return list; }
public Collection<? extends PDefinition> getDefinitions( AMapletPatternMaplet p, SMapType map, NameScope scope) { List<PDefinition> list = new Vector<PDefinition>(); list.addAll(af.createPPatternAssistant().getDefinitions(p.getFrom(), map.getFrom(), scope)); list.addAll(af.createPPatternAssistant().getDefinitions(p.getTo(), map.getTo(), scope)); return list; } }
private List<PDefinition> getMultipleBindDefs(List<PMultipleBind> bindings) { List<PDefinition> defs = new Vector<PDefinition>(); for (PMultipleBind mb : bindings) { for (PPattern pattern : mb.getPlist()) { defs.addAll(af.createPPatternAssistant().getDefinitions(pattern, af.createPMultipleBindAssistant().getPossibleType(mb), NameScope.LOCAL)); } } return defs; }
public List<? extends PDefinition> getParamDefinitions( AExplicitOperationDefinition node) { List<PDefinition> defs = new Vector<PDefinition>(); Iterator<PType> titer = ((AOperationType) node.getType()).getParameters().iterator(); for (PPattern p : node.getParameterPatterns()) { defs.addAll(af.createPPatternAssistant().getDefinitions(p, titer.next(), NameScope.LOCAL)); } return af.createPDefinitionAssistant().checkDuplicatePatterns(node, defs); }
@Override public List<PDefinition> caseAUnionPattern(AUnionPattern pattern, NewQuestion question) throws AnalysisException { List<PDefinition> defs = new Vector<PDefinition>(); if (!af.createPTypeAssistant().isSet(question.ptype)) { TypeCheckerErrors.report(3206, "Matching expression is not a set type", pattern.getLocation(), pattern); } defs.addAll(af.createPPatternAssistant().getDefinitions(pattern.getLeft(), question.ptype, question.scope)); defs.addAll(af.createPPatternAssistant().getDefinitions(pattern.getRight(), question.ptype, question.scope)); return defs; }
@Override public List<PDefinition> caseAMapUnionPattern(AMapUnionPattern pattern, NewQuestion question) throws AnalysisException { List<PDefinition> defs = new Vector<PDefinition>(); if (!af.createPTypeAssistant().isMap(question.ptype)) { TypeCheckerErrors.report(3315, "Matching expression is not a map type", pattern.getLocation(), pattern); } defs.addAll(af.createPPatternAssistant().getDefinitions(pattern.getLeft(), question.ptype, question.scope)); defs.addAll(af.createPPatternAssistant().getDefinitions(pattern.getRight(), question.ptype, question.scope)); return defs; }
public List<PDefinition> getDefinitions(APatternTypePair result) { return af.createPPatternAssistant().getDefinitions(result.getPattern(), result.getType(), NameScope.LOCAL); }
defs.addAll(af.createPPatternAssistant().getDefinitions(p, unknown, NameScope.LOCAL)); defs.addAll(af.createPPatternAssistant().getDefinitions(p, titer.next(), NameScope.LOCAL));
@Override public List<PDefinition> caseATuplePattern(ATuplePattern pattern, NewQuestion question) throws AnalysisException { List<PDefinition> defs = new Vector<PDefinition>(); if (!af.createPTypeAssistant().isProduct(question.ptype, pattern.getPlist().size())) { TypeCheckerErrors.report(3205, "Matching expression is not a product of cardinality " + pattern.getPlist().size(), pattern.getLocation(), pattern); TypeCheckerErrors.detail("Actual", question.ptype); return defs; } AProductType product = af.createPTypeAssistant().getProduct(question.ptype, pattern.getPlist().size()); Iterator<PType> ti = product.getTypes().iterator(); for (PPattern p : pattern.getPlist()) { defs.addAll(af.createPPatternAssistant().getDefinitions(p, ti.next(), question.scope)); } return defs; }
@Override public List<PDefinition> caseASeqPattern(ASeqPattern pattern, NewQuestion question) throws AnalysisException { List<PDefinition> defs = new Vector<PDefinition>(); if (!af.createPTypeAssistant().isSeq(question.ptype)) { TypeCheckerErrors.report(3203, "Sequence pattern is matched against " + question.ptype, pattern.getLocation(), pattern); } else { PType elem = af.createPTypeAssistant().getSeq(question.ptype).getSeqof(); for (PPattern p : pattern.getPlist()) { defs.addAll(af.createPPatternAssistant().getDefinitions(p, elem, question.scope)); } } return defs; }
@Override public List<PDefinition> caseASetPattern(ASetPattern pattern, NewQuestion question) throws AnalysisException { // return ASetPatternAssistantTC.getAllDefinitions(pattern, question.ptype, question.scope); List<PDefinition> defs = new Vector<PDefinition>(); if (!af.createPTypeAssistant().isSet(question.ptype)) { TypeCheckerErrors.report(3204, "Set pattern is not matched against set type", pattern.getLocation(), pattern); TypeCheckerErrors.detail("Actual type", question.ptype); } else { SSetType set = af.createPTypeAssistant().getSet(question.ptype); if (!set.getEmpty()) { for (PPattern p : pattern.getPlist()) { defs.addAll(af.createPPatternAssistant().getDefinitions(p, set.getSetof(), question.scope)); } } } return defs; }
paramDefinitions.addAll(question.assistantFactory.createPPatternAssistant().getDefinitions(tb.getPattern(), tb.getType(), NameScope.LOCAL)); paramPatterns.add(tb.getPattern()); tb.setType(question.assistantFactory.createPTypeAssistant().typeResolve(tb.getType(), null, THIS, question));
defs.addAll(af.createPPatternAssistant().getDefinitions(npp.getPattern(), d.getType(), NameScope.LOCAL));
@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); } }
public void updateDefs(AValueDefinition node, TypeCheckInfo question) { PType type = node.getType(); PPattern pattern = node.getPattern(); List<PDefinition> newdefs = af.createPPatternAssistant().getDefinitions(pattern, type, node.getNameScope()); // The untyped definitions may have had "used" markers, so we copy // those into the new typed definitions, lest we get warnings. We // also mark the local definitions as "ValueDefintions" (proxies), // so that classes can be constructed correctly (values are statics). for (PDefinition d : newdefs) { for (PDefinition u : node.getDefs()) { if (u.getName().equals(d.getName())) { if (af.createPDefinitionAssistant().isUsed(u)) { af.createPDefinitionAssistant().markUsed(d); } break; } } ALocalDefinition ld = (ALocalDefinition) d; ld.setValueDefinition(node.clone()); } node.setDefs(newdefs); List<PDefinition> defs = node.getDefs(); af.createPDefinitionListAssistant().setAccessibility(defs, node.getAccess().clone()); af.createPDefinitionListAssistant().setClassDefinition(defs, node.getClassDefinition()); }
node.getDefs().addAll(question.assistantFactory.createPPatternAssistant().getDefinitions(node.getPattern(), stm.getExp().getType(), NameScope.LOCAL));
@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(); } }