@Override public LexNameSet caseATypeMultipleBind(ATypeMultipleBind node, FreeVarInfo info) throws AnalysisException { return node.getType().apply(this, info); }
@Override public PType caseATypeMultipleBind(ATypeMultipleBind mb) throws AnalysisException { return af.createPPatternListAssistant().getPossibleType(mb.getPlist(), mb.getLocation()); }
public static List<PMultipleBind> bindListFromPattern(PPattern pattern, PType type) { List<PMultipleBind> bindList = new LinkedList<PMultipleBind>(); ATypeMultipleBind tmBind = new ATypeMultipleBind(); List<PPattern> plist = new LinkedList<PPattern>(); plist.add(pattern.clone()); tmBind.setPlist(plist); tmBind.setType(type.clone()); bindList.add(tmBind); return bindList; }
/** * Returns a deep clone of this {@link ATypeMultipleBind} node. * @return a deep clone of this {@link ATypeMultipleBind} node */ public ATypeMultipleBind clone() { return new ATypeMultipleBind( _location, cloneList(_plist), _type ); }
public static ATypeMultipleBind newATypeMultipleBind(List<PPattern> plist, PType readType) { ATypeMultipleBind result = new ATypeMultipleBind(); result.setLocation(plist.get(0).getLocation()); result.setPlist(plist); result.setType(readType); return result; }
/** * Called by the {@link ATypeMultipleBind} node from {@link ATypeMultipleBind#apply(IPOFAnalysis)}. * @param node the calling {@link ATypeMultipleBind} node */ public void caseATypeMultipleBind(ATypeMultipleBind node) throws AnalysisException { _visitedNodes.add(node); inATypeMultipleBind(node); { List<PPattern> copy = new ArrayList<PPattern>(node.getPlist()); for( PPattern e : copy) { if(!_visitedNodes.contains(e)) { e.apply(this); } } } if(node.getType() != null && !_visitedNodes.contains(node.getType())) { node.getType().apply(this); } outATypeMultipleBind(node); }
@Override public PType caseATypeMultipleBind(ATypeMultipleBind node, TypeCheckInfo question) throws AnalysisException { question.assistantFactory.createPPatternListAssistant().typeResolve(node.getPlist(), THIS, question); PType type = question.assistantFactory.createPTypeAssistant().typeResolve(node.getType(), null, THIS, question); PType ptype = question.assistantFactory.createPPatternListAssistant().getPossibleType(node.getPlist(), node.getLocation()); if (!question.assistantFactory.getTypeComparator().compatible(ptype, type)) { TypeCheckerErrors.report(3265, "At least one bind cannot match this type", type.getLocation(), type); TypeCheckerErrors.detail2("Binds", ptype, "Type", type); } node.setType(type); return type; }
/** * Creates a new complete constructor {@code ATypeMultipleBind} node with the given nodes as children. * @deprecated This method should not be used, use AstFactory instead. * The basic child nodes are removed from their previous parents. * @param type_ the {@link PType} <b>graph</a> node for the {@code type} child of this {@link ATypeMultipleBind} node. * <i>The parent of this {@code type } will not be changed by adding it to this node.</i> */ public ATypeMultipleBind(ILexLocation location_, List<? extends PPattern> plist_, PType type_) { super(location_,plist_); this.setType(type_); }
/** * Called by the {@link ATypeMultipleBind} node from {@link ATypeMultipleBind#apply(IAnalysis)}. * @param node the calling {@link ATypeMultipleBind} node */ public void caseATypeMultipleBind(ATypeMultipleBind node, Q question) throws AnalysisException { _visitedNodes.add(node); inATypeMultipleBind(node, question); { List<PPattern> copy = new ArrayList<PPattern>(node.getPlist()); for( PPattern e : copy) { if(!_visitedNodes.contains(e)) { e.apply(this, question); } } } if(node.getType() != null && !_visitedNodes.contains(node.getType())) { node.getType().apply(this, question); } outATypeMultipleBind(node, question); }
/** * Creates a deep clone of this {@link ATypeMultipleBind} node while putting all * old node-new node relations in the map {@code oldToNewMap}. * @param oldToNewMap the map filled with the old node-new node relation * @return a deep clone of this {@link ATypeMultipleBind} node */ public ATypeMultipleBind clone(Map<INode,INode> oldToNewMap) { ATypeMultipleBind node = new ATypeMultipleBind( _location, cloneList(_plist, oldToNewMap), _type ); oldToNewMap.put(this, node); return node; }
private List<PMultipleBind> makeBinds() { List<PMultipleBind> result = new LinkedList<PMultipleBind>(); Iterator<PType> types = argtypes.iterator(); for (List<PPattern> params : paramPatternList) { for (PPattern param : params) { ATypeMultipleBind typeBind = new ATypeMultipleBind(); List<PPattern> one = new Vector<PPattern>(); one.add(param.clone()); typeBind.setPlist(one); PType type = types.next(); typeBind.setType(type.clone()); result.add(typeBind); } } return result; }
/** * Called by the {@link ATypeMultipleBind} node from {@link ATypeMultipleBind#apply(IAnalysis)}. * @param node the calling {@link ATypeMultipleBind} node */ public void caseATypeMultipleBind(ATypeMultipleBind node) throws AnalysisException { _visitedNodes.add(node); inATypeMultipleBind(node); { List<PPattern> copy = new ArrayList<PPattern>(node.getPlist()); for( PPattern e : copy) { if(!_visitedNodes.contains(e)) { e.apply(this); } } } if(node.getType() != null && !_visitedNodes.contains(node.getType())) { node.getType().apply(this); } outATypeMultipleBind(node); }
@Override public ValueList caseATypeMultipleBind(ATypeMultipleBind node, BindState state) throws AnalysisException { return af.createPTypeAssistant().getAllValues(node.getType(), state.ctxt); }
private void addParameterBinds(LinkedList<PMultipleBind> r) { Iterator<PType> types = deftype.getParameters().iterator(); for (PPattern p : paramPatternList) { ATypeMultipleBind tmBind = new ATypeMultipleBind(); List<PPattern> pats = new LinkedList<PPattern>(); pats.add(p.clone()); tmBind.setType(types.next().clone()); tmBind.setPlist(pats); r.add(tmBind); } }
/** * Called by the {@link ATypeMultipleBind} node from {@link ATypeMultipleBind#apply(IAnalysis)}. * @param node the calling {@link ATypeMultipleBind} node */ public A caseATypeMultipleBind(ATypeMultipleBind node, Q question) throws AnalysisException { _visitedNodes.add(node); A retVal = createNewReturnValue(node, question); mergeReturns(retVal,inATypeMultipleBind(node, question)); { List<PPattern> copy = new ArrayList<PPattern>(node.getPlist()); for( PPattern e : copy) { if(!_visitedNodes.contains(e)) { mergeReturns(retVal,e.apply(this, question)); } } } if(node.getType() != null && !_visitedNodes.contains(node.getType())) { mergeReturns(retVal,node.getType().apply(this, question)); } mergeReturns(retVal,outATypeMultipleBind(node, question)); return retVal; }
/** * Create a multiple type bind with a varargs list of pattern variables, like a,b,c:T. This is used by several * obligations. */ protected PMultipleBind getMultipleTypeBind(PType patternType, ILexNameToken... patternNames) { ATypeMultipleBind typeBind = new ATypeMultipleBind(); List<PPattern> patternList = new Vector<PPattern>(); for (ILexNameToken patternName : patternNames) { AIdentifierPattern pattern = new AIdentifierPattern(); pattern.setName(patternName.clone()); patternList.add(pattern); } typeBind.setPlist(patternList); typeBind.setType(patternType.clone()); return typeBind; }
/** * Called by the {@link ATypeMultipleBind} node from {@link ATypeMultipleBind#apply(IAnalysis)}. * @param node the calling {@link ATypeMultipleBind} node */ public A caseATypeMultipleBind(ATypeMultipleBind node) throws AnalysisException { _visitedNodes.add(node); A retVal = createNewReturnValue(node); mergeReturns(retVal,inATypeMultipleBind(node)); { List<PPattern> copy = new ArrayList<PPattern>(node.getPlist()); for( PPattern e : copy) { if(!_visitedNodes.contains(e)) { mergeReturns(retVal,e.apply(this)); } } } if(node.getType() != null && !_visitedNodes.contains(node.getType())) { mergeReturns(retVal,node.getType().apply(this)); } mergeReturns(retVal,outATypeMultipleBind(node)); return retVal; }
protected void addStateBinds(LinkedList<PMultipleBind> r) { if (stateDefinition != null) { ATypeMultipleBind tmBind2 = new ATypeMultipleBind(); AIdentifierPattern pattern = new AIdentifierPattern(); if (stateDefinition instanceof AStateDefinition) { AStateDefinition def = (AStateDefinition) stateDefinition; tmBind2.setType(def.getRecordType().clone()); pattern.setName(OLD_STATE_ARG.clone()); } else { SClassDefinition def = (SClassDefinition) stateDefinition; tmBind2.setType(def.getClasstype().clone()); pattern.setName(OLD_SELF_ARG.clone()); } List<PPattern> plist = new LinkedList<PPattern>(); plist.add(pattern); tmBind2.setPlist(plist); r.add(tmBind2); } }
@Override public SMultipleBindIR caseATypeMultipleBind(ATypeMultipleBind node, IRInfo question) throws AnalysisException { List<PPattern> patterns = node.getPlist(); PType boundType = node.getType(); List<SPatternIR> patternsCg = new LinkedList<SPatternIR>(); for (PPattern pattern : patterns) { SPatternIR patternTempCg = pattern.apply(question.getPatternVisitor(), question); if (patternTempCg != null) { patternsCg.add(patternTempCg); } else { return null; } } STypeIR boundTypeCg = boundType.apply(question.getTypeVisitor(), question); ATypeMultipleBindIR multipleSetBind = new ATypeMultipleBindIR(); multipleSetBind.setPatterns(patternsCg); multipleSetBind.setType(boundTypeCg); return multipleSetBind; }
/** * Create the context (forall x,y,z...) for a Proof Obligation for * eq and ord relations. */ protected AForAllExp makeRelContext(ATypeDefinition node, AVariableExp... exps){ AForAllExp forall_exp = new AForAllExp(); forall_exp.setType(new ABooleanBasicType()); ATypeMultipleBind tmb = new ATypeMultipleBind(); List<PPattern> pats = new LinkedList<>(); for (AVariableExp exp : exps) { pats.add(AstFactory.newAIdentifierPattern(exp.getName().clone())); } tmb.setPlist(pats); tmb.setType(node.getType().clone()); List<PMultipleBind> binds = new LinkedList<>(); binds.add(tmb); forall_exp.setBindList(binds); return forall_exp; }