@Override public STypeIR caseAUnknownType(AUnknownType node, IRInfo question) throws AnalysisException { return new AUnknownTypeIR(); // '?' Indicates an unknown type }
/** * Called by the {@link AUnknownTypeIR} node from {@link AUnknownTypeIR#apply(IIsaAnalysis)}. * @param node the calling {@link AUnknownTypeIR} node */ public void caseAUnknownTypeIR(AUnknownTypeIR node) throws AnalysisException { _visitedNodes.add(node); inAUnknownTypeIR(node); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { node.getNamedInvType().apply(this); } outAUnknownTypeIR(node); }
/** * Returns a deep clone of this {@link AUnknownTypeIR} node. * @return a deep clone of this {@link AUnknownTypeIR} node */ public AUnknownTypeIR clone() { return new AUnknownTypeIR( _sourceNode, _tag, _metaData, _optional, cloneNode(_namedInvType) ); }
/** * Essentially this.toString().equals(o.toString()). **/ @Override public boolean equals(Object o) { if (o != null && o instanceof AUnknownTypeIR) { return toString().equals(o.toString()); } return false; }
@Override public STypeIR caseAUnresolvedType(AUnresolvedType node, IRInfo question) throws AnalysisException { log.error("Found unresolved type in the VDM AST"); // To guard against unresolved type in the type checker return new AUnknownTypeIR(); }
/** * Creates a deep clone of this {@link AUnknownTypeIR} node while putting all * old node-new node relations in the map {@code oldToNewMap}. * @param oldToNewMap the map filled with the old node-new node relation * @return a deep clone of this {@link AUnknownTypeIR} node */ public AUnknownTypeIR clone(Map<INode,INode> oldToNewMap) { AUnknownTypeIR node = new AUnknownTypeIR( _sourceNode, _tag, _metaData, _optional, cloneNode(_namedInvType, oldToNewMap) ); oldToNewMap.put(this, node); return node; }
/** * Called by the {@link AUnknownTypeIR} node from {@link AUnknownTypeIR#apply(IAnalysis)}. * @param node the calling {@link AUnknownTypeIR} node */ public void caseAUnknownTypeIR(AUnknownTypeIR node) throws AnalysisException { _visitedNodes.add(node); inAUnknownTypeIR(node); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { node.getNamedInvType().apply(this); } outAUnknownTypeIR(node); }
@Override public void caseANullPatternIR(ANullPatternIR node, STypeIR question) throws AnalysisException { storeType(node, new AUnknownTypeIR()); }
/** * Called by the {@link AUnknownTypeIR} node from {@link AUnknownTypeIR#apply(IAnalysis)}. * @param node the calling {@link AUnknownTypeIR} node */ public void caseAUnknownTypeIR(AUnknownTypeIR node, Q question) throws AnalysisException { _visitedNodes.add(node); inAUnknownTypeIR(node, question); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { node.getNamedInvType().apply(this, question); } outAUnknownTypeIR(node, question); }
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); }
/** * Called by the {@link AUnknownTypeIR} node from {@link AUnknownTypeIR#apply(IAnalysis)}. * @param node the calling {@link AUnknownTypeIR} node */ public A caseAUnknownTypeIR(AUnknownTypeIR node) throws AnalysisException { _visitedNodes.add(node); A retVal = createNewReturnValue(node); mergeReturns(retVal,inAUnknownTypeIR(node)); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { mergeReturns(retVal,node.getNamedInvType().apply(this)); } mergeReturns(retVal,outAUnknownTypeIR(node)); return retVal; }
public static STypeIR getType(PatternTypeFinder typeFinder, AIdentifierPatternIR occ) { STypeIR occType = typeFinder.getPatternType(occ); if (occType == null) { log.error("Could not find type of identifier pattern " + occ); occType = new AUnknownTypeIR(); } else { occType = occType.clone(); } return occType; } }
/** * Called by the {@link AUnknownTypeIR} node from {@link AUnknownTypeIR#apply(IAnalysis)}. * @param node the calling {@link AUnknownTypeIR} node */ public A caseAUnknownTypeIR(AUnknownTypeIR node, Q question) throws AnalysisException { _visitedNodes.add(node); A retVal = createNewReturnValue(node, question); mergeReturns(retVal,inAUnknownTypeIR(node, question)); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { mergeReturns(retVal,node.getNamedInvType().apply(this, question)); } mergeReturns(retVal,outAUnknownTypeIR(node, question)); return retVal; }
public AUndefinedExpIR consUndefinedExp() { AUndefinedExpIR undefExp = new AUndefinedExpIR(); undefExp.setType(new AUnknownTypeIR()); return undefExp; }
public ANullExpIR consNullExp() { ANullExpIR nullExp = new ANullExpIR(); nullExp.setType(new AUnknownTypeIR()); return nullExp; }
public STypeIR getElementType(STypeIR t) { STypeIR elementType; if (t instanceof ASetSetTypeIR) { elementType = ((ASetSetTypeIR) t).getSetOf().clone(); } else if (t instanceof ASeqSeqTypeIR) { elementType = ((ASeqSeqTypeIR) t).getSeqOf().clone(); } else { String vdmNodeInfo = info.getLocationAssistant().consVdmNodeInfoStr(t); log.error("Expected set or sequence type. Got: " + t.getClass().getName() + "." + vdmNodeInfo); elementType = new AUnknownTypeIR(); elementType.setSourceNode(t.getSourceNode()); } return elementType; }
@Override public void caseAFuncDeclIR(AFuncDeclIR node) throws AnalysisException { super.caseAFuncDeclIR(node); if (!node.getTemplateTypes().isEmpty()) { for(ATemplateTypeIR t : node.getTemplateTypes()) { AFormalParamLocalParamIR param = new AFormalParamLocalParamIR(); param.setType(new AUnknownTypeIR()); param.setPattern(assist.getInfo().getPatternAssistant().consIdPattern(toTypeArgName(t))); node.getFormalParams().add(param); } } }
public String formatElementType(STypeIR type) throws AnalysisException { if (type instanceof SSetTypeIR) { SSetTypeIR setType = (SSetTypeIR) type; return format(setType.getSetOf()); } else if (type instanceof SSeqTypeIR) { SSeqTypeIR seqType = (SSeqTypeIR) type; return format(seqType.getSeqOf()); } else if (type instanceof AStringTypeIR) { return format(new ACharBasicTypeIR()); } else { String vdmNodeInfo = info.getLocationAssistant().consVdmNodeInfoStr(type); log.error("Expected set, seq or string type when trying to format element type. Got: " + type + ". " + vdmNodeInfo); return format(new AUnknownTypeIR()); } }
private STypeIR getFieldType(IRInfo info, String fieldName, String fieldModule, SObjectDesignatorIR obj) { if (fieldModule != null) { // It is a class return info.getTypeAssistant().getFieldType(info.getClasses(), fieldModule, fieldName); } else { // It is a record try { ObjectDesignatorToExpIR converter = new ObjectDesignatorToExpIR(info); SExpIR objExp = obj.apply(converter); if (objExp.getType() instanceof ARecordTypeIR) { STypeIR fieldExpType = info.getTypeAssistant().getFieldType(info.getClasses(), (ARecordTypeIR) objExp.getType(), fieldName); if (fieldExpType == null) { log.error("Could not find field type"); } return fieldExpType; } } catch (org.overture.codegen.ir.analysis.AnalysisException e) { } } log.error("Could not determine field type"); return new AUnknownTypeIR(); }
@Override public SExpIR caseAFieldObjectDesignatorIR(AFieldObjectDesignatorIR node) throws AnalysisException { String fieldName = node.getFieldName(); String fieldModule = node.getFieldModule(); SObjectDesignatorIR obj = node.getObject(); SourceNode sourceNode = node.getSourceNode(); INode parent = node.parent(); STypeIR fieldExpType = null; try { fieldExpType = info.getTypeAssistant().getFieldExpType(info, fieldName, fieldModule, obj, parent); } catch (org.overture.ast.analysis.AnalysisException e) { log.error("Could not find field expression type of " + node); fieldExpType = new AUnknownTypeIR(); } SExpIR objExp = obj.apply(this); AFieldExpIR fieldExp = new AFieldExpIR(); fieldExp.setMemberName(fieldName); fieldExp.setType(fieldExpType); fieldExp.setObject(objExp); fieldExp.setSourceNode(sourceNode); return fieldExp; }