private void add(ABlockStmIR block, AMetaStmIR as) { if (as != null) { block.getStatements().add(as); } }
private boolean singleBlockWrapsBlock(ABlockStmIR node) { return node.getLocalDefs().isEmpty() && node.getStatements().size() == 1 && node.getStatements().get(0) instanceof ABlockStmIR; }
private void addSubjectAsserts(AMetaStmIR recAssert, List<AMetaStmIR> namedTypeInvAssert, ABlockStmIR replBlock) { for (AMetaStmIR a : consSubjectAsserts(recAssert, namedTypeInvAssert)) { replBlock.getStatements().add(a); } }
public static String getSimpleBlockString(ABlockStmIR node) { StringBuilder sb = new StringBuilder(); String sep = ""; for (SStmIR s : node.getStatements()) { sb.append(sep); sb.append(s.toString()); sep = ";\n"; } sb.append("\n"); return sb.toString(); }
public ABlockStmIR wrap(SStmIR stm) { ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(stm); return block; } }
public void injectDeclAsStm(ABlockStmIR block, AVarDeclIR decl) { ABlockStmIR wrappingBlock = new ABlockStmIR(); wrappingBlock.getLocalDefs().add(decl); block.getStatements().add(wrappingBlock); }
public void appendStoreRegStms(ABlockStmIR declBlock, String varName, String idConstName, boolean staticReg) { // Passing the variable type as the unknown type is not very accurate. // However, it simplifies the store registration. declBlock.getStatements().add(consStoreRegistration(idConstName, new AUnknownTypeIR(), varName, staticReg)); idConstNameMap.put(varName, idConstName); }
protected void transform(SStmIR enclosingStm, ABlockStmIR block, SExpIR nodeResult, SExpIR node) { // Replace the node with the node result transAssistant.replaceNodeWith(node, nodeResult); // Replace the enclosing statement with the transformation transAssistant.replaceNodeWith(enclosingStm, block); // And make sure to have the enclosing statement in the transformed tree block.getStatements().add(enclosingStm); }
private void addAssert(AAssignToExpStmIR node, AMetaStmIR assertStm) { ABlockStmIR replStm = new ABlockStmIR(); getJmlGen().getJavaGen().getTransAssistant().replaceNodeWith(node, replStm); replStm.getStatements().add(node); replStm.getStatements().add(assertStm); }
protected void handleLogicExp(SBoolBinaryExpIR node, SStmIR enclosingStm, SStmIR checkBlock, String resultName) throws AnalysisException { AVarDeclIR andResultDecl = transAssistant.consBoolVarDecl(resultName, false); ABlockStmIR declBlock = new ABlockStmIR(); declBlock.getLocalDefs().add(andResultDecl); ABlockStmIR replacementBlock = new ABlockStmIR(); transAssistant.replaceNodeWith(enclosingStm, replacementBlock); transAssistant.replaceNodeWith(node, transAssistant.consBoolCheck(resultName, false)); replacementBlock.getStatements().add(declBlock); replacementBlock.getStatements().add(checkBlock); replacementBlock.getStatements().add(enclosingStm); replacementBlock.apply(this); }
private ABlockStmIR consPatternHandlingBlock(List<PatternInfo> patternInfo) { ABlockStmIR topBlock = new ABlockStmIR(); for (PatternInfo info : patternInfo) { SPatternIR currentPattern = info.getPattern(); if (!basicCaseHandled(currentPattern)) { ABlockStmIR currentDeclBlock = new ABlockStmIR(); ABlockStmIR patternHandlingBlock = consPatternCheck(currentPattern, info.getType(), info.getActualValue(), currentDeclBlock); currentDeclBlock.getStatements().addFirst(patternHandlingBlock); topBlock.getStatements().add(currentDeclBlock); } } return topBlock; }
private AMethodDeclIR consToStringMethod(String name) { SExpIR stringLit = info.getExpAssistant().consStringLiteral("<" + name + ">", false); AReturnStmIR returnStr = new AReturnStmIR(); returnStr.setExp(stringLit); AMethodDeclIR toStringMethod = consToStringSignature(); ABlockStmIR body = new ABlockStmIR(); body.getStatements().add(returnStr); toStringMethod.setBody(body); return toStringMethod; }
public void caseALetDefExpIR(ALetDefExpIR node) throws AnalysisException { SStmIR enclosingStm = transAssistant.getEnclosingStm(node, "let def expression"); SExpIR exp = node.getExp(); transAssistant.replaceNodeWith(node, exp); ABlockStmIR topBlock = new ABlockStmIR(); ABlockStmIR current = topBlock; for (AVarDeclIR local : node.getLocalDefs()) { ABlockStmIR tmp = new ABlockStmIR(); tmp.getLocalDefs().add(local.clone()); current.getStatements().add(tmp); current = tmp; } transAssistant.replaceNodeWith(enclosingStm, topBlock); topBlock.getStatements().add(enclosingStm); exp.apply(this); topBlock.apply(this); topBlock.setScoped(transAssistant.getInfo().getStmAssistant().isScoped(topBlock)); }
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 void initSuccessVar(PatternBlockData patternData, SExpIR initExp, ABlockStmIR patternBlock) { if (patternData.getSuccessVarDecl().getExp() instanceof AUndefinedExpIR) { patternData.getSuccessVarDecl().setExp(initExp); } else { AAssignToExpStmIR successVarAssignment = new AAssignToExpStmIR(); successVarAssignment.setTarget(patternData.getSuccessVar().clone()); successVarAssignment.setExp(initExp); patternBlock.getStatements().add(successVarAssignment); } }
protected SStmIR handleVoidValueReturn(SStmIR stm) { AExternalTypeIR traceNodeClassType = new AExternalTypeIR(); traceNodeClassType.setName(traceTrans.getTracePrefixes().voidValueEnclosingClassName()); AExplicitVarExpIR voidValue = new AExplicitVarExpIR(); voidValue.setType(new AObjectTypeIR()); voidValue.setClassType(traceNodeClassType); voidValue.setIsLambda(false); voidValue.setIsLocal(true); voidValue.setName(traceTrans.getTracePrefixes().voidValueFieldName()); AReturnStmIR returnVoidVal = new AReturnStmIR(); returnVoidVal.setExp(voidValue); ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(stm); block.getStatements().add(returnVoidVal); return block; }
@Override public SStmIR caseALetStm(ALetStm node, IRInfo question) throws AnalysisException { ABlockStmIR block = new ABlockStmIR(); block.setScoped(question.getStmAssistant().isScoped(node)); question.getDeclAssistant().setFinalLocalDefs(node.getLocalDefs(), block.getLocalDefs(), question); SStmIR stm = node.getStatement().apply(question.getStmVisitor(), question); if (stm != null) { block.getStatements().add(stm); } return block; }
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); }
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; }
private ABlockStmIR consUnionTypedTuplePatternCheck( boolean declarePatternVar, AUnionTypeIR unionType, PatternBlockData patternData, SExpIR actualValue, ATuplePatternIR tuplePattern) { ATupleTypeIR resTupleType = transAssistant.getInfo().getPatternAssistant().getTupleType(unionType, tuplePattern); ABlockStmIR tuplePatternCheck = consTuplePatternCheck(declarePatternVar, tuplePattern, resTupleType, patternData, actualValue, true); AIsOfClassExpIR instanceCheck = new AIsOfClassExpIR(); instanceCheck.setType(new ABoolBasicTypeIR()); instanceCheck.setCheckedType(patternData.getRootPatternVar().getType().clone()); instanceCheck.setExp(patternData.getRootPatternVar().clone()); AIfStmIR typeCheck = new AIfStmIR(); typeCheck.setIfExp(instanceCheck); typeCheck.setThenStm(tuplePatternCheck); ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(typeCheck); return block; }