@Override public ATypeBindAssistantTC createATypeBindAssistant() { return new ATypeBindAssistantTC(this); }
@Override public PMultipleBindAssistantTC createPMultipleBindAssistant() { return new PMultipleBindAssistantTC(this); }
@Override public PPatternAssistantTC createPPatternAssistant() { return new PPatternAssistantTC(this); }
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 boolean isSimple(LinkedList<PPattern> p) { for (PPattern pattern : p) { if (!af.createPPatternAssistant().isSimple(pattern)) { return false; // NB. AND } } return true; }
@Override public PType caseASeqMultipleBind(ASeqMultipleBind mb) throws AnalysisException { return af.createPPatternListAssistant().getPossibleType(mb.getPlist(), mb.getLocation()); }
public void typeResolve(List<PPattern> pp, IQuestionAnswer<TypeCheckInfo, PType> rootVisitor, TypeCheckInfo question) throws AnalysisException { for (PPattern pattern : pp) { af.createPPatternAssistant().typeResolve(pattern, rootVisitor, question); } }
public boolean alwaysMatches(List<PPattern> pl) { for (PPattern p : pl) { if (!af.createPPatternAssistant().alwaysMatches(p)) { return false; // NB. AND } } return true; }
public void unResolve() { for (PPattern pPattern : this) { af.createPPatternAssistant().unResolve(pPattern); } }
@Override public PPatternListAssistantTC createPPatternListAssistant() { return new PPatternListAssistantTC(this); }
@Override public APatternTypePairAssistant createAPatternTypePairAssistant() { return new APatternTypePairAssistant(this); }
@Override public PatternListTC createPatternList() { return new PatternListTC(this); }
@Override public PBindAssistantTC createPBindAssistant() { return new PBindAssistantTC(this); }
@Override public Boolean caseASeqPattern(ASeqPattern pattern) throws AnalysisException { return af.createPPatternListAssistant().isSimple(pattern.getPlist()); }
@Override public LexNameList caseAValueDefinition(AValueDefinition node) throws AnalysisException { return af.createPPatternAssistant().getVariableNames(node.getPattern()); }
@Override public void caseASetPattern(ASetPattern pattern) throws AnalysisException { af.createPPatternListAssistant().unResolve(pattern.getPlist()); pattern.setResolved(false); }
public void typeResolve( QuestionAnswerAdaptor<TypeCheckInfo, PType> rootVisitor, TypeCheckInfo question) throws AnalysisException { for (PPattern pPattern : this) { af.createPPatternAssistant().typeResolve(pPattern, rootVisitor, question); } }
@Override public Boolean caseAConcatenationPattern(AConcatenationPattern node) throws AnalysisException { return af.createPPatternAssistant().alwaysMatches(node.getLeft()) && af.createPPatternAssistant().alwaysMatches(node.getRight()); }
public void unResolve(List<PPattern> pp) { for (PPattern pPattern : pp) { af.createPPatternAssistant().unResolve(pPattern); } }
public void typeResolvePairs(List<ANamePatternPair> npplist, IQuestionAnswer<TypeCheckInfo, PType> rootVisitor, TypeCheckInfo question) throws AnalysisException { for (ANamePatternPair npp : npplist) { af.createPPatternAssistant().typeResolve(npp.getPattern(), rootVisitor, question); } }