@Override public STypeIR caseABooleanBasicType(ABooleanBasicType node, IRInfo question) throws AnalysisException { return new ABoolBasicTypeIR(); } }
@Override public void caseABoolPatternIR(ABoolPatternIR node, STypeIR question) throws AnalysisException { storeType(node, new ABoolBasicTypeIR()); }
/** * Returns a deep clone of this {@link ABoolBasicTypeIR} node. * @return a deep clone of this {@link ABoolBasicTypeIR} node */ public ABoolBasicTypeIR clone() { return new ABoolBasicTypeIR( _sourceNode, _tag, _metaData, _optional, cloneNode(_namedInvType) ); }
@Override public void inANotUnaryExpIR(ANotUnaryExpIR node) throws AnalysisException { correctTypes(node.getExp(), new ABoolBasicTypeIR()); }
@Override public SExpIR getForLoopCond(AIdentifierVarExpIR setVar, List<SPatternIR> patterns, SPatternIR pattern) throws AnalysisException { AClassTypeIR iteratorType = transAssistant.consClassType(ITERATOR_TYPE); return transAssistant.consInstanceCall(iteratorType, iteratorName, new ABoolBasicTypeIR(), HAS_NEXT_ELEMENT_ITERATOR); }
public ABoolLiteralExpIR consBoolLiteral(boolean val) { ABoolLiteralExpIR boolLiteral = new ABoolLiteralExpIR(); boolLiteral.setType(new ABoolBasicTypeIR()); boolLiteral.setValue(val); return boolLiteral; }
public static ATupleIsExpIR consTupleIsExp(SExpIR exp, STypeIR checkedType) { ATupleIsExpIR tupleIsExp = new ATupleIsExpIR(); tupleIsExp.setType(new ABoolBasicTypeIR()); tupleIsExp.setExp(exp); tupleIsExp.setCheckedType(checkedType); return tupleIsExp; }
public SExpIR consAndExp(SExpIR left, SExpIR right) { AAndBoolBinaryExpIR andExp = new AAndBoolBinaryExpIR(); andExp.setType(new ABoolBasicTypeIR()); andExp.setLeft(left); andExp.setRight(right); return andExp; }
public static SExpIR consGeneralIsExp(SExpIR expCg, STypeIR checkedTypeCg) { AGeneralIsExpIR generalIsExp = new AGeneralIsExpIR(); generalIsExp = new AGeneralIsExpIR(); generalIsExp.setType(new ABoolBasicTypeIR()); generalIsExp.setExp(expCg); generalIsExp.setCheckedType(checkedTypeCg); return generalIsExp; }
@Override public void inAIfStmIR(AIfStmIR node) throws AnalysisException { ABoolBasicTypeIR expectedType = new ABoolBasicTypeIR(); correctTypes(node.getIfExp(), expectedType); LinkedList<AElseIfStmIR> elseIfs = node.getElseIf(); for (AElseIfStmIR currentElseIf : elseIfs) { correctTypes(currentElseIf.getElseIf(), expectedType); } }
public AIdentifierVarExpIR consSuccessVar(String successVarName) { AIdentifierVarExpIR successVar = new AIdentifierVarExpIR(); successVar.setIsLambda(false); successVar.setIsLocal(true); successVar.setName(successVarName); successVar.setType(new ABoolBasicTypeIR()); return successVar; }
public AAndBoolBinaryExpIR extendAndExp(ARecordDeclIR record, AFieldDeclIR field, SExpIR previous, String paramName) throws AnalysisException { // By recursively calling this method an "and chain" of field // comparisons can be constructed: fieldComp1 && fieldComp2 && fieldComp3 .... AAndBoolBinaryExpIR nextAnd = new AAndBoolBinaryExpIR(); nextAnd.setType(new ABoolBasicTypeIR()); nextAnd.setLeft(previous); nextAnd.setRight(consFieldComparison(record, field, paramName)); return nextAnd; }
private AIsOfClassExpIR consInstanceCheck(SExpIR copy, STypeIR type) { AIsOfClassExpIR check = new AIsOfClassExpIR(); check.setType(new ABoolBasicTypeIR()); check.setCheckedType(type.clone()); check.setExp(copy.clone()); return check; }
public AVarDeclIR consBoolVarDecl(String boolVarName, boolean initValue) { return info.getDeclAssistant().consLocalVarDecl(new ABoolBasicTypeIR(), info.getPatternAssistant().consIdPattern(boolVarName), info.getExpAssistant().consBoolLiteral(initValue)); }
public static SExpIR consIsExpQuoteType(SExpIR exp, AQuoteTypeIR quoteType) { AQuoteLiteralExpIR lit = new AQuoteLiteralExpIR(); lit.setType(quoteType); lit.setValue(quoteType.getValue()); AEqualsBinaryExpIR equals = new AEqualsBinaryExpIR(); equals.setType(new ABoolBasicTypeIR()); equals.setLeft(exp); equals.setRight(lit); return equals; }
public SExpIR consLessThanCheck(String varName, long value) { AIdentifierVarExpIR left = new AIdentifierVarExpIR(); left.setType(new AIntNumericBasicTypeIR()); left.setIsLocal(true); left.setName(varName); AIntLiteralExpIR right = info.getExpAssistant().consIntLiteral(value); ALessNumericBinaryExpIR less = new ALessNumericBinaryExpIR(); less.setType(new ABoolBasicTypeIR()); less.setLeft(left); less.setRight(right); return less; }
protected AMethodDeclIR initPredDecl(String name) { AMethodTypeIR methodType = new AMethodTypeIR(); methodType.setResult(new ABoolBasicTypeIR()); AMethodDeclIR meetsPredMethod = new AMethodDeclIR(); meetsPredMethod.setImplicit(false); meetsPredMethod.setAbstract(false); meetsPredMethod.setAccess(IRConstants.PUBLIC); meetsPredMethod.setAsync(false); meetsPredMethod.setIsConstructor(false); meetsPredMethod.setMethodType(methodType); meetsPredMethod.setStatic(false); meetsPredMethod.setName(name); return meetsPredMethod; }
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 AAddrNotEqualsBinaryExpIR consParamNotNullComp( AIdentifierVarExpIR param) { AAddrNotEqualsBinaryExpIR fieldComparison = new AAddrNotEqualsBinaryExpIR(); fieldComparison.setType(new ABoolBasicTypeIR()); AIdentifierVarExpIR instanceField = new AIdentifierVarExpIR(); instanceField.setType(param.getType().clone()); instanceField.setIsLocal(true); instanceField.setName(param.getName()); fieldComparison.setLeft(instanceField); fieldComparison.setRight(info.getExpAssistant().consNullExp()); return fieldComparison; }
@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); }