public ABlockStmIR wrap(SStmIR stm) { ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(stm); return block; } }
public ABlockStmIR consIterationBlock(List<SPatternIR> ids, SExpIR set, ITempVarGen tempGen, IIterationStrategy strategy, IterationVarPrefixes iteVarPrefixes) throws AnalysisException { ABlockStmIR outerBlock = new ABlockStmIR(); consIterationBlock(outerBlock, ids, set, tempGen, strategy, iteVarPrefixes); return outerBlock; }
public ABlockStmIR wrap(AVarDeclIR decl) { ABlockStmIR block = new ABlockStmIR(); block.getLocalDefs().add(decl); return block; }
public void injectDeclAsStm(ABlockStmIR block, AVarDeclIR decl) { ABlockStmIR wrappingBlock = new ABlockStmIR(); wrappingBlock.getLocalDefs().add(decl); block.getStatements().add(wrappingBlock); }
/** * Returns a deep clone of this {@link ABlockStmIR} node. * @return a deep clone of this {@link ABlockStmIR} node */ public ABlockStmIR clone() { return new ABlockStmIR( _sourceNode, _tag, _metaData, _scoped, cloneList(_localDefs), cloneList(_statements) ); }
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; }
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 void addAssert(AAssignToExpStmIR node, AMetaStmIR assertStm) { ABlockStmIR replStm = new ABlockStmIR(); getJmlGen().getJavaGen().getTransAssistant().replaceNodeWith(node, replStm); replStm.getStatements().add(node); replStm.getStatements().add(assertStm); }
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; }
@Override public void caseANonDeterministicBlockStmIR(ANonDeterministicBlockStmIR node) throws AnalysisException { super.caseANonDeterministicBlockStmIR(node); ABlockStmIR block = new ABlockStmIR(); block.setScoped(false); block.setTag(node.getTag()); block.setSourceNode(node.getSourceNode()); if(!node.getStatements().isEmpty()) { // Just use the first statement block.getStatements().add(node.getStatements().getFirst().clone()); } else { log.error("nondeterministic statement block did not contain any statements: " + node); } assist.replaceNodeWith(node, block); } }
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 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; }
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 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 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; }
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; }
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; }
public AMethodDeclIR consDefaultContructor(String name) { AMethodDeclIR constructor = new AMethodDeclIR(); AClassTypeIR classType = new AClassTypeIR(); classType.setName(name); AMethodTypeIR methodType = new AMethodTypeIR(); methodType.setResult(classType); constructor.setMethodType(methodType); constructor.setAccess(IRConstants.PUBLIC); constructor.setAbstract(false); constructor.setIsConstructor(true); constructor.setName(name); constructor.setImplicit(false); constructor.setBody(new ABlockStmIR()); return constructor; }
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 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; }