public void setFinalLocalDefs(List<PDefinition> localDefs, List<AVarDeclIR> localDecls, IRInfo question) throws AnalysisException { for (PDefinition def : localDefs) { AVarDeclIR varDecl = null; if (def instanceof AValueDefinition) { varDecl = consLocalVarDecl((AValueDefinition) def, question); } else if (def instanceof AEqualsDefinition) { varDecl = consLocalVarDecl((AEqualsDefinition) def, question); } if (varDecl != null) { varDecl.setFinal(true); localDecls.add(varDecl); } else { log.error("Problems encountered when trying to construct local variable"); } } }
public AVarDeclIR consNextElementDeclared(STypeIR iteratorType, STypeIR elementType, SPatternIR id, String iteratorName, String nextElementMethod) throws AnalysisException { ACastUnaryExpIR cast = consNextElementCall(iteratorType, iteratorName, elementType, nextElementMethod); return info.getDeclAssistant().consLocalVarDecl(elementType, id.clone(), cast); }
public AVarDeclIR consLocalVarDecl(STypeIR type, SPatternIR pattern, SExpIR exp) { return consLocalVarDecl(exp.getSourceNode() != null ? exp.getSourceNode().getVdmNode() : null, type, pattern, exp); }
public AVarDeclIR consDecl(String varName, STypeIR type, SExpIR exp) { return info.getDeclAssistant().consLocalVarDecl(type, info.getPatternAssistant().consIdPattern(varName), exp); }
@Override public List<AVarDeclIR> getOuterBlockDecls(AIdentifierVarExpIR setVar, List<SPatternIR> patterns) throws AnalysisException { List<AVarDeclIR> outerBlockDecls = new LinkedList<AVarDeclIR>(); STypeIR elementType = transAssist.getElementType(setSeqType); for (SPatternIR id : patterns) { AVarDeclIR decl = transAssist.getInfo().getDeclAssistant().consLocalVarDecl(elementType.clone(), id.clone(), transAssist.getInfo().getExpAssistant().consUndefinedExp()); decls.add(decl); outerBlockDecls.add(decl); } successVarDecl = transAssist.consBoolVarDecl(successVarName, false); outerBlockDecls.add(successVarDecl); return outerBlockDecls; }
public AVarDeclIR consSetBindDecl(String setBindName, SExpIR col) throws AnalysisException { return info.getDeclAssistant().consLocalVarDecl(col.getType().clone(), info.getPatternAssistant().consIdPattern(setBindName), col.clone()); }
private ABlockStmIR initPattern(boolean declare, SPatternIR pattern, STypeIR type, SExpIR actualValue, AIdentifierPatternIR idPattern) { ABlockStmIR patternBlock = new ABlockStmIR(); if (declare) { AVarDeclIR patternDecl = transAssistant.getInfo().getDeclAssistant().consLocalVarDecl(type.clone(), idPattern.clone(), actualValue.clone()); patternBlock.getLocalDefs().add(patternDecl); } else { transAssistant.replaceNodeWith(pattern, idPattern); } return patternBlock; }
public AVarDeclIR consBoolVarDecl(String boolVarName, boolean initValue) { return info.getDeclAssistant().consLocalVarDecl(new ABoolBasicTypeIR(), info.getPatternAssistant().consIdPattern(boolVarName), info.getExpAssistant().consBoolLiteral(initValue)); }
private ABlockStmIR consIdVarDeclaration(PatternInfo currentInfo, SPatternIR currentPattern) { AIdentifierPatternIR idPattern = (AIdentifierPatternIR) currentPattern; AVarDeclIR idPatternDecl = transAssistant.getInfo().getDeclAssistant().consLocalVarDecl(currentInfo.getType().clone(), idPattern.clone(), currentInfo.getActualValue().clone()); ABlockStmIR wrappingStatement = new ABlockStmIR(); wrappingStatement.getLocalDefs().add(idPatternDecl); return wrappingStatement; }
@Override public List<AVarDeclIR> getOuterBlockDecls(AIdentifierVarExpIR setVar, List<SPatternIR> patterns) throws AnalysisException { if (firstBind) { IRInfo info = transAssist.getInfo(); AIdentifierPatternIR resId = new AIdentifierPatternIR(); resId.setName(resultVarName); List<AVarDeclIR> decls = new LinkedList<>(); STypeIR elemType = transAssist.getElementType(setVar.getType()); AUndefinedExpIR initExp = info.getExpAssistant().consUndefinedExp(); decls.add(info.getDeclAssistant().consLocalVarDecl(elemType, resId, initExp)); AIdentifierPatternIR countId = new AIdentifierPatternIR(); countId.setName(counterName); decls.add(consCounterDecl(info, countId)); return decls; } else { return null; } }
@Override public List<AVarDeclIR> getOuterBlockDecls(AIdentifierVarExpIR setVar, List<SPatternIR> patterns) throws AnalysisException { STypeIR elementType = transAssist.getElementType(setSeqType); for (SPatternIR id : patterns) { AVarDeclIR decl = transAssist.getInfo().getDeclAssistant().consLocalVarDecl(elementType.clone(), id.clone(), transAssist.getInfo().getExpAssistant().consUndefinedExp()); decl.setFinal(true); decls.add(decl); } return packDecl(altTests); }
@Override public List<AVarDeclIR> getOuterBlockDecls(AIdentifierVarExpIR setVar, List<SPatternIR> patterns) throws AnalysisException { SExpIR emptyCollection = getEmptyCollection(); emptyCollection.setType(compType.clone()); AVarDeclIR compResultInit = transAssist.getInfo().getDeclAssistant().consLocalVarDecl(compType.clone(), idPattern.clone(), emptyCollection); return packDecl(compResultInit); } }
private AVarDeclIR consLocalVarDecl(AValueDefinition valueDef, IRInfo question) throws AnalysisException { STypeIR type = valueDef.getType().apply(question.getTypeVisitor(), question); SPatternIR pattern = valueDef.getPattern().apply(question.getPatternVisitor(), question); SExpIR exp = valueDef.getExpression().apply(question.getExpVisitor(), question); return consLocalVarDecl(valueDef, type, pattern, exp); }
private AVarDeclIR consLocalVarDecl(AEqualsDefinition equalsDef, IRInfo question) throws AnalysisException { STypeIR type = equalsDef.getExpType().apply(question.getTypeVisitor(), question); SPatternIR pattern = equalsDef.getPattern().apply(question.getPatternVisitor(), question); SExpIR exp = equalsDef.getTest().apply(question.getExpVisitor(), question); return consLocalVarDecl(equalsDef, type, pattern, exp); }
@Override public List<AVarDeclIR> getOuterBlockDecls(AIdentifierVarExpIR setVar, List<SPatternIR> patterns) throws AnalysisException { if (firstBind) { AIdentifierPatternIR name = new AIdentifierPatternIR(); name.setName(resultVarName); return packDecl(transAssist.getInfo().getDeclAssistant().consLocalVarDecl(counterData.getType().clone(), name, counterData.getExp().clone())); } else { return null; } }
public AVarDeclIR consCounterDecl(IRInfo info, AIdentifierPatternIR countId) { return transAssist.getInfo().getDeclAssistant().consLocalVarDecl(counterData.getType().clone(), transAssist.getInfo().getPatternAssistant().consIdPattern(counterName), counterData.getExp().clone()); }
private AAssignToExpStmIR declareAndAssignIdVarAssignment( ABlockStmIR declBlock, SPatternIR currentPattern, STypeIR currentType, SExpIR valueToMatch) { AIdentifierPatternIR currentId = (AIdentifierPatternIR) currentPattern; AVarDeclIR idVarDecl = transAssistant.getInfo().getDeclAssistant().consLocalVarDecl(currentType.clone(), currentPattern.clone(), new AUndefinedExpIR()); declBlock.getLocalDefs().add(idVarDecl); AIdentifierVarExpIR var = new AIdentifierVarExpIR(); var.setType(currentType.clone()); var.setName(currentId.getName()); var.setIsLocal(true); var.setIsLambda(false); AAssignToExpStmIR localAssignment = new AAssignToExpStmIR(); localAssignment.setTarget(var); localAssignment.setExp(valueToMatch); return localAssignment; }
public ABlockStmIR consVarFromCastedExp(ARecordDeclIR record, String formalParamName, String varName) throws AnalysisException { // Construct a local var in a statement: RecordType varName = ((RecordType) formalParamName); ARecordTypeIR recordType = new ARecordTypeIR(); recordType.setName(consTypeName(record)); AIdentifierPatternIR idPattern = new AIdentifierPatternIR(); idPattern.setName(varName); ACastUnaryExpIR cast = new ACastUnaryExpIR(); cast.setType(recordType.clone()); AIdentifierVarExpIR varExp = new AIdentifierVarExpIR(); varExp.setType(new AObjectTypeIR()); varExp.setName(formalParamName); varExp.setIsLocal(true); cast.setExp(varExp); AVarDeclIR localVar = info.getDeclAssistant().consLocalVarDecl(recordType, idPattern, cast); ABlockStmIR stm = new ABlockStmIR(); stm.getLocalDefs().add(localVar); return stm; }
@Override public AVarDeclIR getForLoopInit(AIdentifierVarExpIR setVar, List<SPatternIR> patterns, SPatternIR pattern) { iteratorName = transAssistant.getInfo().getTempVarNameGen().nextVarName(iteVarPrefixes.iterator()); String setName = setVar.getName(); AClassTypeIR iteratorType = transAssistant.consClassType(ITERATOR_TYPE); STypeIR setType = setVar.getType().clone(); SExpIR getIteratorCall = transAssistant.consInstanceCall(setType, setName, iteratorType.clone(), GET_ITERATOR); return transAssistant.getInfo().getDeclAssistant().consLocalVarDecl(iteratorType, transAssistant.getInfo().getPatternAssistant().consIdPattern(iteratorName), getIteratorCall); }
public void handleReturn(AReturnStmIR node) throws AnalysisException { /** * The idea is to extract the return value to variable and return that variable. Then it becomes the * responsibility of the variable declaration case to assert if the named invariant type is violated. */ SExpIR exp = node.getExp(); AMethodDeclIR encMethod = decorator.getJmlGen().getUtil().getEnclosingMethod(node); if (encMethod == null) { return; } STypeIR returnType = encMethod.getMethodType().getResult(); AbstractTypeInfo typeInfo = util.findTypeInfo(returnType); if (!proceed(typeInfo)) { return; } String name = getInfo().getTempVarNameGen().nextVarName(RET_VAR_NAME_PREFIX); AIdentifierPatternIR id = getInfo().getPatternAssistant().consIdPattern(name); AIdentifierVarExpIR varExp = getInfo().getExpAssistant().consIdVar(name, returnType.clone()); getTransAssist().replaceNodeWith(exp, varExp); AVarDeclIR varDecl = getInfo().getDeclAssistant().consLocalVarDecl(returnType.clone(), id, exp.clone()); ABlockStmIR replBlock = new ABlockStmIR(); replBlock.getLocalDefs().add(varDecl); getTransAssist().replaceNodeWith(node, replBlock); replBlock.getStatements().add(node); varDecl.apply(decorator); }