public ACallObjectExpStmIR consStoreRegistration(String idConstName, STypeIR varType, String varName, boolean staticReg) { AIdentifierVarExpIR idVar = transAssistant.getInfo().getExpAssistant().consIdVar(varName, varType); return consStoreRegistration(idConstName, idVar, staticReg); }
private AMethodDeclIR consHashcodeMethod() { AIdentifierVarExpIR hashCodeVar = transAssistant.getInfo().getExpAssistant().consIdVar(HASHCODE_FIELD, consFieldType()); AReturnStmIR returnHashCode = new AReturnStmIR(); returnHashCode.setExp(hashCodeVar); AMethodDeclIR hashCodeMethod = consHashcodeMethodSignature(); ABlockStmIR body = new ABlockStmIR(); body.getStatements().add(returnHashCode); hashCodeMethod.setBody(body); return hashCodeMethod; }
private ACastUnaryExpIR consObjId() { String paramName = tracePrefixes.callStmMethodParamName(); AIdentifierVarExpIR idVar = assist.getInfo().getExpAssistant().consIdVar(paramName, new AObjectTypeIR()); ACastUnaryExpIR castVar = new ACastUnaryExpIR(); castVar.setType(assist.consClassType(traceEnclosingClass)); castVar.setExp(idVar); return castVar; }
private void setFieldNames(AFieldExpIR field, AStateDeclIR stateDecl, String name) { ARecordTypeIR recType = transAssistant.getRecType(stateDecl); String stateName = stateDecl.getName(); if (info.getExpAssistant().isOld(name)) { field.setObject(transAssistant.getInfo().getExpAssistant().consIdVar("_" + stateName, recType)); field.setMemberName(info.getExpAssistant().oldNameToCurrentName(name)); } else { field.setObject(transAssistant.getInfo().getExpAssistant().consIdVar(stateName, recType)); field.setMemberName(name); } } }
public ACallObjectExpStmIR consStoreRegistration(String idConstName, SExpIR subject, boolean staticReg) { AIdentifierVarExpIR idVarExp = transAssistant.getInfo().getExpAssistant().consIdVar(idConstName, new ANatNumericBasicTypeIR()); AClassTypeIR storageType = transAssistant.consClassType(tracePrefixes.storeClassName()); String storeVarName = tracePrefixes.storeVarName(); String method = staticReg ? tracePrefixes.storeStaticRegistrationMethodName() : tracePrefixes.storeRegistrationMethodName(); return transAssistant.consInstanceCallStm(storageType, storeVarName, method, idVarExp, subject); }
public AIdentifierVarExpIR getInvParamVar(AMethodDeclIR invMethod) { AFormalParamLocalParamIR formalParam = getInvFormalParam(invMethod); if (formalParam == null) { return null; } String paramName = getName(formalParam.getPattern()); if (paramName == null) { return null; } STypeIR paramType = formalParam.getType().clone(); return jmlGen.getJavaGen().getInfo().getExpAssistant().consIdVar(paramName, paramType); }
private SStmIR buildTestExecutionStms(AIdentifierVarExpIR nodeVar, String traceEnclosingClassName) { AExternalTypeIR utilsType = new AExternalTypeIR(); utilsType.setName(tracePrefixes.traceNodeNodeClassName()); APlainCallStmIR executeTestsCall = new APlainCallStmIR(); executeTestsCall.setClassType(utilsType); executeTestsCall.setName(tracePrefixes.executeTestsMethodName()); executeTestsCall.setType(new AVoidTypeIR()); ATypeArgExpIR typeArg = new ATypeArgExpIR(); typeArg.setType(transAssistant.consClassType(traceEnclosingClassName)); executeTestsCall.getArgs().add(nodeVar.clone()); if (Settings.dialect != Dialect.VDM_SL) { executeTestsCall.getArgs().add(typeArg); } executeTestsCall.getArgs().add(transAssistant.getInfo().getExpAssistant().consIdVar(tracePrefixes.traceMethodParamName(), transAssistant.consClassType(tracePrefixes.testAccumulatorClassName()))); executeTestsCall.getArgs().add(transAssistant.getInfo().getExpAssistant().consIdVar(tracePrefixes.storeVarName(), transAssistant.consClassType(tracePrefixes.storeClassName()))); return executeTestsCall; }
@Override public TraceNodeData caseATraceDeclTermIR(ATraceDeclTermIR node) throws AnalysisException { String name = getInfo().getTempVarNameGen().nextVarName(traceTrans.getTracePrefixes().altTraceNodeNamePrefix()); AClassTypeIR classType = getTransAssist().consClassType(traceTrans.getTracePrefixes().altTraceNodeNodeClassName()); if (node.getTraceDecls().size() == 1) { return node.getTraceDecls().getFirst().apply(this); } { AVarDeclIR altTests = getTransAssist().consDecl(name, classType, getTransAssist().consDefaultConsCall(classType)); ABlockStmIR stms = new ABlockStmIR(); stms.getLocalDefs().add(altTests); List<SStmIR> addStms = new LinkedList<SStmIR>(); for (STraceDeclIR traceDecl : node.getTraceDecls()) { TraceNodeData nodeData = traceDecl.apply(this); stms.getStatements().add(nodeData.getStms()); addStms.add(getTransAssist().consInstanceCallStm(classType, name, traceTrans.getTracePrefixes().addMethodName(), nodeData.getNodeVar())); } stms.getStatements().addAll(addStms); return new TraceNodeData(getInfo().getExpAssistant().consIdVar(name, classType.clone()), stms, stms); } }
private AMethodDeclIR consEqualsMethod(String name) { AIdentifierVarExpIR paramVar = transAssistant.getInfo().getExpAssistant().consIdVar(EQUALS_METHOD_PARAM, new AObjectTypeIR()); AClassTypeIR quoteClass = new AClassTypeIR(); quoteClass.setName(name); AIsOfClassExpIR instanceCheck = new AIsOfClassExpIR(); instanceCheck.setType(new ABoolBasicTypeIR()); instanceCheck.setExp(paramVar); instanceCheck.setCheckedType(quoteClass); AReturnStmIR checkReturned = new AReturnStmIR(); checkReturned.setExp(instanceCheck); AMethodDeclIR equalsMethod = consEqualMethodSignature(EQUALS_METHOD_PARAM); ABlockStmIR body = new ABlockStmIR(); body.getStatements().add(checkReturned); equalsMethod.setBody(body); return equalsMethod; }
@Override public TraceNodeData caseAConcurrentExpTraceCoreDeclIR( AConcurrentExpTraceCoreDeclIR node) throws AnalysisException { String name = getInfo().getTempVarNameGen().nextVarName(traceTrans.getTracePrefixes().concTraceNodeNamePrefix()); AClassTypeIR classType = getTransAssist().consClassType(traceTrans.getTracePrefixes().concTraceNodeNodeClassName()); AVarDeclIR concNodeDecl = getTransAssist().consDecl(name, classType, getTransAssist().consDefaultConsCall(classType)); ABlockStmIR stms = new ABlockStmIR(); stms.getLocalDefs().add(concNodeDecl); List<SStmIR> addStms = new LinkedList<SStmIR>(); // The number of declarations is > 1 for (STraceDeclIR term : node.getDecls()) { TraceNodeData nodeData = term.apply(this); AIdentifierVarExpIR var = nodeData.getNodeVar(); nodeData.getNodeVarScope().getStatements().add(getTransAssist().consInstanceCallStm(classType, name, traceTrans.getTracePrefixes().addMethodName(), var)); stms.getStatements().add(nodeData.getStms()); } stms.getStatements().addAll(addStms); return new TraceNodeData(getInfo().getExpAssistant().consIdVar(name, classType.clone()), stms, stms); }
call.getArgs().add(assist.getInfo().getExpAssistant().consIdVar(argName, param.getType().clone()));
public TraceNodeData buildFromDeclTerms(List<ATraceDeclTermIR> terms) throws AnalysisException { String name = getInfo().getTempVarNameGen().nextVarName(traceTrans.getTracePrefixes().seqTraceNodeNamePrefix()); AClassTypeIR classType = getTransAssist().consClassType(traceTrans.getTracePrefixes().seqClassTypeName()); AVarDeclIR seqNodeDecl = getTransAssist().consDecl(name, classType, getTransAssist().consDefaultConsCall(classType)); ABlockStmIR stms = new ABlockStmIR(); stms.getLocalDefs().add(seqNodeDecl); for (ATraceDeclTermIR term : terms) { TraceNodeData nodeData = term.apply(this); stms.getStatements().add(nodeData.getStms()); AIdentifierVarExpIR var = nodeData.getNodeVar(); nodeData.getNodeVarScope().getStatements().add(getTransAssist().consInstanceCallStm(classType, name, traceTrans.getTracePrefixes().addMethodName(), var)); } return new TraceNodeData(getInfo().getExpAssistant().consIdVar(name, classType.clone()), stms, stms); }
public SExpIR consStoreLookup(AIdentifierVarExpIR node, boolean noCast) { AClassTypeIR storeType = transAssistant.consClassType(tracePrefixes.storeClassName()); AIdentifierVarExpIR idArg = transAssistant.getInfo().getExpAssistant().consIdVar(idConstNameMap.get(node.getName()), new ANatNumericBasicTypeIR()); SExpIR call = transAssistant.consInstanceCall(storeType, tracePrefixes.storeVarName(), node.getType(), tracePrefixes.storeGetValueMethodName(), idArg); if (noCast || node.getType() instanceof AUnionTypeIR || node.getType() instanceof AUnknownTypeIR || node.getType() instanceof AObjectTypeIR) { return call; } else { ACastUnaryExpIR cast = new ACastUnaryExpIR(); cast.setType(node.getType().clone()); cast.setExp(call); return cast; } } }
@Override public List<SStmIR> getPostOuterBlockStms(AIdentifierVarExpIR setVar, List<SPatternIR> patterns) { AEqualsBinaryExpIR noMatches = new AEqualsBinaryExpIR(); noMatches.setType(new ABoolBasicTypeIR()); noMatches.setLeft(transAssist.getInfo().getExpAssistant().consIdVar(counterName, new AIntNumericBasicTypeIR())); noMatches.setRight(transAssist.getInfo().getExpAssistant().consIntLiteral(0)); AIfStmIR ifStm = new AIfStmIR(); ifStm.setIfExp(noMatches); ifStm.setThenStm(consIotaMultipleResultsError()); return packStm(ifStm); }
private AMethodDeclIR consSetter(AFieldDeclIR f) { AMethodDeclIR setter = new AMethodDeclIR(); setter.setAbstract(false); setter.setAccess(IRConstants.PUBLIC); setter.setAsync(false); setter.setImplicit(false); setter.setIsConstructor(false); setter.setName(consSetCallName(f.getName())); setter.setStatic(false); setter.setSourceNode(f.getSourceNode()); String paramName = consParamName(f); AFormalParamLocalParamIR param = new AFormalParamLocalParamIR(); param.setType(f.getType().clone()); param.setPattern(jmlGen.getJavaGen().getInfo().getPatternAssistant().consIdPattern(paramName)); setter.getFormalParams().add(param); AMethodTypeIR methodType = new AMethodTypeIR(); methodType.setResult(new AVoidTypeIR()); methodType.getParams().add(f.getType().clone()); setter.setMethodType(methodType); AAssignToExpStmIR fieldUpdate = new AAssignToExpStmIR(); fieldUpdate.setTarget(jmlGen.getJavaGen().getInfo().getExpAssistant().consIdVar(f.getName(), f.getType().clone())); fieldUpdate.setExp(jmlGen.getJavaGen().getInfo().getExpAssistant().consIdVar(paramName, f.getType().clone())); setter.setBody(fieldUpdate); return setter; }
@Override public TraceNodeData caseARepeatTraceDeclIR(ARepeatTraceDeclIR node) throws AnalysisException { Long from = node.getFrom(); Long to = node.getTo(); if (from == 1 && to == 1) { return node.getCore().apply(this); } else { String name = getInfo().getTempVarNameGen().nextVarName(traceTrans.getTracePrefixes().repeatTraceNodeNamePrefix()); TraceNodeData traceData = node.getCore().apply(this); AIdentifierVarExpIR varArg = traceData.getNodeVar(); AIntLiteralExpIR fromArg = getInfo().getExpAssistant().consIntLiteral(from); AIntLiteralExpIR toArg = getInfo().getExpAssistant().consIntLiteral(to); AClassTypeIR repeat = getTransAssist().consClassType(traceTrans.getTracePrefixes().repeatTraceNodeNamePrefix()); ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(traceData.getStms()); block.getStatements().add(consDecl(traceTrans.getTracePrefixes().repeatTraceNodeNodeClassName(), name, varArg, fromArg, toArg)); return new TraceNodeData(getInfo().getExpAssistant().consIdVar(name, repeat), block, block); } }
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); }
fieldType.setName(IJavaConstants.INT); AIdentifierVarExpIR hashcodeVar = transAssistant.getInfo().getExpAssistant().consIdVar(HASHCODE_FIELD, fieldType); hashcodeCompare.setRight(consZero()); AIdentifierVarExpIR hashCodeId = transAssistant.getInfo().getExpAssistant().consIdVar(HASHCODE_FIELD, consFieldType());
private AMethodDeclIR consGetter(AFieldDeclIR f) { AMethodDeclIR getter = new AMethodDeclIR(); getter.setAbstract(false); getter.setAccess(IRConstants.PUBLIC); getter.setAsync(false); getter.setImplicit(false); getter.setIsConstructor(false); getter.setName(consGetCallName(f.getName())); getter.setStatic(false); getter.setSourceNode(f.getSourceNode()); AMethodTypeIR methodType = new AMethodTypeIR(); methodType.setResult(f.getType().clone()); getter.setMethodType(methodType); AReturnStmIR returnField = new AReturnStmIR(); returnField.setExp(jmlGen.getJavaGen().getInfo().getExpAssistant().consIdVar(f.getName(), f.getType().clone())); getter.setBody(returnField); jmlGen.getAnnotator().makePure(getter); return getter; }
public SVarExpIR idStateDesignatorToExp(AIdentifierStateDesignatorIR node) { if (node.getExplicit()) { AClassTypeIR classType = new AClassTypeIR(); classType.setName(node.getClassName()); AExplicitVarExpIR explicitVar = new AExplicitVarExpIR(); explicitVar.setClassType(classType); explicitVar.setIsLambda(false); explicitVar.setIsLocal(node.getIsLocal()); explicitVar.setName(node.getName()); explicitVar.setSourceNode(node.getSourceNode()); explicitVar.setTag(node.getTag()); explicitVar.setType(node.getType().clone()); return explicitVar; } else { AIdentifierVarExpIR idVar = consIdVar(node.getName(), node.getType().clone()); idVar.setTag(node.getTag()); idVar.setSourceNode(node.getSourceNode()); idVar.setIsLocal(node.getIsLocal()); return idVar; } }