package org.overture.codegen.vdm2jml;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import org.apache.log4j.Logger;
import org.overture.ast.analysis.AnalysisException;
import org.overture.ast.definitions.SFunctionDefinition;
import org.overture.ast.modules.AModuleModules;
import org.overture.ast.util.ClonableString;
import org.overture.codegen.ir.CodeGenBase;
import org.overture.codegen.ir.INode;
import org.overture.codegen.ir.IRConstants;
import org.overture.codegen.ir.IREventObserver;
import org.overture.codegen.ir.IRInfo;
import org.overture.codegen.ir.IRSettings;
import org.overture.codegen.ir.IRStatus;
import org.overture.codegen.ir.IrNodeInfo;
import org.overture.codegen.ir.PIR;
import org.overture.codegen.ir.SDeclIR;
import org.overture.codegen.ir.SStmIR;
import org.overture.codegen.ir.analysis.DepthFirstAnalysisAdaptor;
import org.overture.codegen.ir.declarations.ADefaultClassDeclIR;
import org.overture.codegen.ir.declarations.AFieldDeclIR;
import org.overture.codegen.ir.declarations.AFormalParamLocalParamIR;
import org.overture.codegen.ir.declarations.AMethodDeclIR;
import org.overture.codegen.ir.declarations.AModuleDeclIR;
import org.overture.codegen.ir.declarations.ANamedTypeDeclIR;
import org.overture.codegen.ir.declarations.ARecordDeclIR;
import org.overture.codegen.ir.declarations.ATypeDeclIR;
import org.overture.codegen.ir.declarations.AVarDeclIR;
import org.overture.codegen.ir.declarations.SClassDeclIR;
import org.overture.codegen.ir.expressions.ACastUnaryExpIR;
import org.overture.codegen.ir.expressions.AIdentifierVarExpIR;
import org.overture.codegen.ir.statements.ABlockStmIR;
import org.overture.codegen.ir.types.AUnknownTypeIR;
import org.overture.codegen.traces.TracesTrans;
import org.overture.codegen.trans.AssignStmTrans;
import org.overture.codegen.trans.assistants.TransAssistantIR;
import org.overture.codegen.trans.uniontypes.UnionTypeTrans;
import org.overture.codegen.trans.uniontypes.UnionTypeVarPrefixes;
import org.overture.codegen.utils.GeneratedData;
import org.overture.codegen.vdm2java.IJavaQuoteEventObserver;
import org.overture.codegen.vdm2java.JavaCodeGen;
import org.overture.codegen.vdm2java.JavaCodeGenUtil;
import org.overture.codegen.vdm2java.JavaSettings;
import org.overture.codegen.vdm2jml.data.RecClassInfo;
import org.overture.codegen.vdm2jml.data.StateDesInfo;
import org.overture.codegen.vdm2jml.predgen.TypePredDecorator;
import org.overture.codegen.vdm2jml.predgen.info.AbstractTypeInfo;
import org.overture.codegen.vdm2jml.predgen.info.NamedTypeInfo;
import org.overture.codegen.vdm2jml.predgen.info.NamedTypeInvDepCalculator;
import org.overture.codegen.vdm2jml.trans.JmlTraceTrans;
import org.overture.codegen.vdm2jml.trans.JmlUnionTypeTrans;
import org.overture.codegen.vdm2jml.trans.RecAccessorTrans;
import org.overture.codegen.vdm2jml.trans.RecInvTransformation;
import org.overture.codegen.vdm2jml.trans.TargetNormaliserTrans;
import org.overture.codegen.vdm2jml.trans.TcExpInfo;
import org.overture.codegen.vdm2jml.util.AnnotationSorter;
import org.overture.codegen.vdm2jml.util.IsValChecker;
import org.overture.codegen.vdm2jml.util.NameGen;
public class JmlGenerator implements IREventObserver, IJavaQuoteEventObserver
{
private static final String VDM_JML_RUNTIME_IMPORT = "org.overture.codegen.vdm2jml.runtime.*";
public static final String DEFAULT_JAVA_ROOT_PACKAGE = "project";
public static final String GEN_INV_METHOD_PARAM_NAME = "elem";
public static final String INV_PREFIX = "inv_";
public static final String INV_METHOD_REPLACEMENT_NAME_PREFIX = "check_";
public static final String JML_PUBLIC = "public";
public static final String JML_STATIC_INV_ANNOTATION = "static invariant";
public static final String JML_OR = " || ";
public static final String JML_AND = " && ";
public static final String JML_IMPLIES = " ==> ";
public static final String JML_INSTANCE_INV_ANNOTATION = "instance invariant";
public static final String JML_REQ_ANNOTATION = "requires";
public static final String JML_ENS_ANNOTATION = "ensures";
public static final String JML_ASSERT_ANNOTATION = "assert";
public static final String JML_OLD_PREFIX = "\\old";
public static final String JML_SPEC_PUBLIC = "/*@ spec_public @*/";
public static final String JML_PURE = "/*@ pure @*/";
public static final String JML_HELPER = "/*@ helper @*/";
public static final String JML_RESULT = "\\result";
public static final String JML_NULLABLE_BY_DEFAULT = "//@ nullable_by_default";
public static final String INV_CHECKS_ON_GHOST_VAR_NAME = "invChecksOn";
public static final String JML_INV_CHECKS_ON_DECL = "/*@ public ghost static boolean %s = true; @*/";
public static final String JML_SET_INV_CHECKS = "//@ set %s = %s;";
public static final String JML_INVARIANT_FOR = "\\invariant_for";
public static final String REC_VALID_METHOD_NAMEVALID = "valid";
public static final String REC_VALID_METHOD_CALL = REC_VALID_METHOD_NAMEVALID
+ "()";
public static final String JAVA_INSTANCEOF = " instanceof ";
private JavaCodeGen javaGen;
private JmlSettings jmlSettings;
private List<NamedTypeInfo> typeInfoList;
private JmlGenUtil util;
private JmlAnnotationHelper annotator;
private StateDesInfo stateDesInfo;
// The class owning the invChecksOn flag
private ADefaultClassDeclIR invChecksFlagOwner = null;
private List<TcExpInfo> tcExpInfo;
private Logger log = Logger.getLogger(this.getClass().getName());
public JmlGenerator()
{
this(new JavaCodeGen());
}
public JmlGenerator(JavaCodeGen javaGen)
{
this.javaGen = javaGen;
// Named invariant type info will be derived (later) from the VDM-SL AST
this.typeInfoList = null;
this.util = new JmlGenUtil(this);
this.annotator = new JmlAnnotationHelper(this);
initSettings();
addJmlTransformations();
}
private void addJmlTransformations()
{
TargetNormaliserTrans targetNormaliserTrans = new TargetNormaliserTrans(this);
// Info structures are populated with data when the transformations are applied
this.stateDesInfo = targetNormaliserTrans.getStateDesInfo();
List<DepthFirstAnalysisAdaptor> series = this.javaGen.getTransSeries().getSeries();
List<INode> cloneFreeNodes = javaGen.getJavaFormat().getValueSemantics().getCloneFreeNodes();
// Replace the union type transformation
for (int i = 0; i < series.size(); i++)
{
DepthFirstAnalysisAdaptor currentTr = series.get(i);
if (currentTr instanceof UnionTypeTrans)
{
TransAssistantIR assist = javaGen.getTransAssistant();
UnionTypeVarPrefixes varPrefixes = javaGen.getVarPrefixManager().getUnionTypePrefixes();
JmlUnionTypeTrans newUnionTypeTr = new JmlUnionTypeTrans(assist, varPrefixes, cloneFreeNodes, stateDesInfo);
series.set(i, newUnionTypeTr);
} else if (currentTr instanceof TracesTrans)
{
TracesTrans orig = (TracesTrans) currentTr;
JmlTraceTrans newTraceTrans = new JmlTraceTrans(orig.getTransAssist(), orig.getIteVarPrefixes(), orig.getTracePrefixes(), orig.getLangIterator(), orig.getToStringBuilder(), cloneFreeNodes);
series.set(i, newTraceTrans);
this.tcExpInfo = newTraceTrans.getTcExpInfo();
}
}
// Now add the assignment transformation
for (int i = 0; i < series.size(); i++)
{
// We'll add the transformations after the assignment transformation
if (series.get(i).getClass().equals(AssignStmTrans.class))
{
int targetTransIdx = i + 1;
if (targetTransIdx <= series.size())
{
series.add(targetTransIdx, targetNormaliserTrans);
} else
{
log.error("Could not add transformations to the transformation series");
}
break;
}
}
}
private void initSettings()
{
IRSettings irSettings = getIrSettings();
irSettings.setGeneratePreConds(true);
irSettings.setGeneratePreCondChecks(false);
irSettings.setGeneratePostConds(true);
irSettings.setGeneratePostCondChecks(false);
irSettings.setGenerateInvariants(true);
irSettings.setGenerateTraces(true);
JavaSettings javaSettings = getJavaSettings();
javaSettings.setGenRecsAsInnerClasses(false);
this.jmlSettings = new JmlSettings();
}
public GeneratedData generateJml(List<AModuleModules> ast)
throws AnalysisException
{
if (!JavaCodeGenUtil.isValidJavaPackage(getJavaSettings().getJavaRootPackage()))
{
getJavaSettings().setJavaRootPackage(DEFAULT_JAVA_ROOT_PACKAGE);
}
computeNamedTypeInvInfo(ast);
javaGen.registerIrObs(this);
javaGen.registerJavaQuoteObs(this);
return javaGen.generate(CodeGenBase.getNodes(ast));
}
@Override
public List<IRStatus<PIR>> initialIRConstructed(List<IRStatus<PIR>> ast,
IRInfo info)
{
List<IRStatus<AModuleDeclIR>> modules = IRStatus.extract(ast, AModuleDeclIR.class);
for (IRStatus<AModuleDeclIR> m : modules)
{
for (SDeclIR d : m.getIrNode().getDecls())
{
if (d instanceof AFieldDeclIR)
{
AFieldDeclIR f = (AFieldDeclIR) d;
if (f.getInitial() != null && f.getFinal())
{
IsValChecker isVal = new IsValChecker();
try
{
if (!f.getInitial().apply(isVal))
{
Set<IrNodeInfo> wrap = new HashSet<>();
IrNodeInfo warning = new IrNodeInfo(f, "The JML generator only allows literal-based expressions "
+ "to be used to initialise value definitions");
// By requiring that there is no need to assert that it is not null
wrap.add(warning);
m.addTransformationWarnings(wrap);
}
} catch (org.overture.codegen.ir.analysis.AnalysisException e)
{
e.printStackTrace();
}
}
}
}
}
return ast;
}
@Override
public List<IRStatus<PIR>> finalIRConstructed(List<IRStatus<PIR>> ast,
IRInfo info)
{
// In the final version of the IR, received by the Java code generator, all
// top level containers are classes
setInvChecksOnOwner(ast);
annotateRecsWithInvs(ast);
// All the record methods are JML pure
annotator.makeRecMethodsPure(ast);
/**
* Make records accessor-based (i.e. using setters and getters), which will force the record into a visible
* state when modified/read.
*/
RecClassInfo recInfo = makeRecStateAccessorBased(ast);
List<IRStatus<PIR>> newAst = new LinkedList<IRStatus<PIR>>(ast);
// To circumvent a problem with OpenJML. See documentation of makeRecsOuterClasses
newAst.addAll(util.makeRecsOuterClasses(ast, recInfo));
// Also extract classes that are records
for (IRStatus<ADefaultClassDeclIR> status : IRStatus.extract(newAst, ADefaultClassDeclIR.class))
{
ADefaultClassDeclIR clazz = status.getIrNode();
// VDM uses the type system to control whether 'nil' is allowed as a value so we'll
// just annotate all classes as @nullable_by_default
annotator.makeNullableByDefault(clazz);
// Make sure that the classes can access the VDM to JML runtime
addVdmToJmlRuntimeImport(clazz);
}
// Only extract from 'ast' to not get the record classes
for (IRStatus<ADefaultClassDeclIR> status : IRStatus.extract(ast, ADefaultClassDeclIR.class))
{
ADefaultClassDeclIR clazz = status.getIrNode();
if (info.getDeclAssistant().isLibraryName(clazz.getName()))
{
continue;
}
for (AFieldDeclIR f : clazz.getFields())
{
// Make fields JML @spec_public so they can be passed to post conditions.
// However, we'll avoid doing it for public fields as this does not make sense
if (!f.getAccess().equals(IRConstants.PUBLIC))
{
annotator.makeSpecPublic(f);
}
}
// Named type invariant functions will potentially also have to be
// accessed by other modules
annotator.makeNamedTypeInvFuncsPublic(clazz);
// In order for a value to be compatible with a named invariant type
// two conditions must be met:
//
// 1) The type of the value must match the domain type of the named
// type invariant. T = <domainType>
//
// 2) the value must meet the invariant predicate
adjustNamedTypeInvFuncs(status);
// Note that the methods contained in clazz.getMethod() include
// pre post and invariant methods
for (AMethodDeclIR m : clazz.getMethods())
{
if (m.getPreCond() != null)
{
// We need to make pre and post conditions functions public in order to
// be able to call them in the @requires and @ensures clauses, respectively.
annotator.makeCondPublic(m.getPreCond());
annotator.appendMetaData(m, consMethodCond(m.getPreCond(), m.getFormalParams(), JML_REQ_ANNOTATION));
}
if (m.getPostCond() != null)
{
annotator.makeCondPublic(m.getPostCond());
annotator.appendMetaData(m, consMethodCond(m.getPostCond(), m.getFormalParams(), JML_ENS_ANNOTATION));
}
// Some methods such as those in record classes
// will not have a source node. Thus this check.
if (m.getSourceNode() != null)
{
if (m.getSourceNode().getVdmNode() instanceof SFunctionDefinition)
{
annotator.makePure(m);
}
}
}
}
TypePredDecorator assertTr = new TypePredDecorator(this, stateDesInfo, recInfo);
// Add assertions to check for violation of record and named type invariants
addAssertions(newAst, assertTr);
// Make sure that the JML annotations are ordered correctly
sortAnnotations(newAst);
// Make all nodes have a copy of each named type invariant method
util.distributeNamedTypeInvs(newAst);
// Type check trace tests
tcTraceTest(assertTr);
// Return back the modified AST to the Java code generator
return newAst;
}
private void tcTraceTest(TypePredDecorator assertTr)
{
for (TcExpInfo currentInfo : tcExpInfo)
{
AbstractTypeInfo typeInfo = assertTr.getTypePredUtil().findTypeInfo(currentInfo.getFormalParamType());
String enclosingClass = currentInfo.getTraceEnclosingClass();
String javaRootPackage = getJavaSettings().getJavaRootPackage();
SClassDeclIR clazz = getJavaGen().getInfo().getDeclAssistant().findClass(getJavaGen().getInfo().getClasses(), enclosingClass);
NameGen nameGen = new NameGen(clazz);
String expRef = currentInfo.getExpRef();
String checkStr = typeInfo.consCheckExp(enclosingClass, javaRootPackage, expRef, nameGen);
currentInfo.getTypeCheck().setMetaData(annotator.consMetaData("//@ "
+ JML_ASSERT_ANNOTATION + " " + checkStr + ";"));
}
}
private void addVdmToJmlRuntimeImport(ADefaultClassDeclIR clazz)
{
String vdmJmlRuntimeImport = VDM_JML_RUNTIME_IMPORT;
List<ClonableString> allImports = new LinkedList<>();
allImports.addAll(clazz.getDependencies());
allImports.add(new ClonableString(vdmJmlRuntimeImport));
clazz.setDependencies(allImports);
}
private RecClassInfo makeRecStateAccessorBased(List<IRStatus<PIR>> ast)
{
RecAccessorTrans recAccTr = new RecAccessorTrans(this);
for (IRStatus<PIR> status : ast)
{
try
{
javaGen.getIRGenerator().applyPartialTransformation(status, recAccTr);
} catch (org.overture.codegen.ir.analysis.AnalysisException e)
{
log.error("Could not apply '" + RecAccessorTrans.class
+ "' to status " + status.getIrNodeName());
e.printStackTrace();
}
}
return recAccTr.getRecInfo();
}
private void sortAnnotations(List<IRStatus<PIR>> newAst)
{
AnnotationSorter sorter = new AnnotationSorter();
for (IRStatus<ADefaultClassDeclIR> status : IRStatus.extract(newAst, ADefaultClassDeclIR.class))
{
if (!javaGen.getInfo().getDeclAssistant().isLibraryName(status.getIrNode().getName()))
{
try
{
status.getIrNode().apply(sorter);
} catch (org.overture.codegen.ir.analysis.AnalysisException e)
{
log.error("Could not sort JML annotations for node "
+ status.getIrNode());
e.printStackTrace();
}
}
}
}
private void computeNamedTypeInvInfo(List<AModuleModules> ast)
throws AnalysisException
{
NamedTypeInvDepCalculator depCalc = new NamedTypeInvDepCalculator(this.getJavaGen().getInfo());
for (AModuleModules m : ast)
{
if (!javaGen.getInfo().getDeclAssistant().isLibrary(m))
{
m.apply(depCalc);
}
}
this.typeInfoList = depCalc.getTypeDataList();
}
private void addAssertions(List<IRStatus<PIR>> newAst,
TypePredDecorator assertTr)
{
for (IRStatus<ADefaultClassDeclIR> status : IRStatus.extract(newAst, ADefaultClassDeclIR.class))
{
ADefaultClassDeclIR clazz = status.getIrNode();
if (!this.javaGen.getInfo().getDeclAssistant().isLibraryName(clazz.getName()))
{
try
{
this.javaGen.getIRGenerator().applyPartialTransformation(status, assertTr);
} catch (org.overture.codegen.ir.analysis.AnalysisException e)
{
log.error("Unexpected problem occured when applying transformation");
e.printStackTrace();
}
}
}
}
private void annotateRecsWithInvs(List<IRStatus<PIR>> ast)
{
List<ARecordDeclIR> recs = util.getRecords(ast);
for (ARecordDeclIR r : recs)
{
if (r.getInvariant() != null)
{
// The record invariant is an instance invariant and the invariant method
// is updated such that it passes the record fields (rather than the record instance)
// to the invariant method. See the changeRecInvMethod for more information about
// this. Also note that there is no need for the record invariant method to guard against
// the record being null (because the invariant is specified as an instance invariant).
changeRecInvMethod(r);
// Must be public otherwise we can't access it from the invariant
annotator.makeCondPublic(r.getInvariant());
// Must be a helper since we use this function from the invariant
annotator.makeHelper(r.getInvariant());
annotator.makePure(r.getInvariant());
// Add the instance invariant to the record
// Make it public so we can access the record fields from the invariant clause
annotator.addRecInv(r);
}
}
}
private void setInvChecksOnOwner(List<IRStatus<PIR>> ast)
{
for (IRStatus<ADefaultClassDeclIR> status : IRStatus.extract(ast, ADefaultClassDeclIR.class))
{
if (invChecksFlagOwner == null)
{
invChecksFlagOwner = status.getIrNode();
annotator.addInvCheckGhostVarDecl(invChecksFlagOwner);
}
}
}
/**
* The record invariant method is generated such that it takes the record instance as an argument, e.g.
* inv_Rec(recToCheck). When I try to invoke it from the instance invariant clause as //@ invariant inv_Rec(this);
* it crashes on a stackoverflow where it keeps calling the invariant check. Adjusting the invariant method such
* that it instead takes the fields as arguments does, however, work. This is exactly what this method does. After
* calling this method a call to the invariant method from the invariant will take the following form: //@ public
* instance invariant inv_Rec(field1,field2);
*
* @param rec
* The record for which we will change the invariant method
*/
private void changeRecInvMethod(ARecordDeclIR rec)
{
try
{
rec.getInvariant().apply(new RecInvTransformation(javaGen, rec));
} catch (org.overture.codegen.ir.analysis.AnalysisException e)
{
log.error("Could not transform the invariant method of a record");
e.printStackTrace();
}
}
private List<ClonableString> consMethodCond(SDeclIR decl,
List<AFormalParamLocalParamIR> parentMethodParams, String jmlAnno)
{
if (decl instanceof AMethodDeclIR)
{
AMethodDeclIR cond = (AMethodDeclIR) decl;
List<String> fieldNames = new LinkedList<String>();
// The arguments of a function or an operation are passed to the pre/post condition
int i;
for (i = 0; i < parentMethodParams.size(); i++)
{
fieldNames.add(util.getMethodCondArgName(parentMethodParams.get(i).getPattern()));
}
// Now compute the remaining argument names which (possibly)
// include the RESULT and the old state passed
for (; i < cond.getFormalParams().size(); i++)
{
fieldNames.add(util.getMethodCondArgName(cond.getFormalParams().get(i).getPattern()));
}
return annotator.consAnno(jmlAnno, cond.getName(), fieldNames);
} else if (decl != null)
{
log.error("Expected pre/post condition to be a method declaration at this point. Got: "
+ decl);
}
return null;
}
public void adjustNamedTypeInvFuncs(IRStatus<ADefaultClassDeclIR> status)
{
ADefaultClassDeclIR clazz = status.getIrNode();
for (ATypeDeclIR typeDecl : clazz.getTypeDecls())
{
if (typeDecl.getDecl() instanceof ANamedTypeDeclIR)
{
ANamedTypeDeclIR namedTypeDecl = (ANamedTypeDeclIR) typeDecl.getDecl();
AMethodDeclIR method = util.getInvMethod(typeDecl);
boolean invMethodIsGen = false;
if (method == null)
{
method = util.genInvMethod(clazz, namedTypeDecl);
typeDecl.setInv(method);
invMethodIsGen = true;
}
String defModule = namedTypeDecl.getName().getDefiningClass();
String name = namedTypeDecl.getName().getName();
method.setName(JmlGenerator.INV_PREFIX + defModule + "_"
+ name);
AFormalParamLocalParamIR invParam = util.getInvFormalParam(method);
AFormalParamLocalParamIR invParamCopy = invParam.clone();
invParam.setType(new AUnknownTypeIR());
String paramName = util.getName(invParam.getPattern());
if (paramName == null)
{
continue;
}
invParam.setPattern(util.consInvParamReplacementId(clazz, paramName));
// Invariant methods are really functions so we'll annotate them as pure
annotator.makePure(method);
// We'll also make it a helper so it can be called from invariants, which is needed for fields
// Otherwise we would get errors on the form:
// "Calling a pure non-helper method in an invariant may lead to unbounded recursive
// invariant checks and stack-overflow: inv_C(java.lang.Object)"
annotator.makeHelper(method);
ABlockStmIR declStmBlock = new ABlockStmIR();
if (!invMethodIsGen)
{
AIdentifierVarExpIR paramVar = util.getInvParamVar(method);
if (paramVar == null)
{
continue;
}
ACastUnaryExpIR cast = new ACastUnaryExpIR();
cast.setType(invParamCopy.getType().clone());
cast.setExp(paramVar.clone());
AVarDeclIR decl = javaGen.getInfo().getDeclAssistant().consLocalVarDecl(invParamCopy.getType(), invParamCopy.getPattern(), cast);
declStmBlock.setScoped(false);
declStmBlock.getLocalDefs().add(decl);
}
SStmIR body = method.getBody();
ABlockStmIR repBlock = new ABlockStmIR();
javaGen.getTransAssistant().replaceNodeWith(body, repBlock);
repBlock.getStatements().add(declStmBlock);
repBlock.getStatements().add(body);
}
}
}
public StateDesInfo normaliseTargets(List<IRStatus<PIR>> newAst)
{
TargetNormaliserTrans normaliser = new TargetNormaliserTrans(this);
for (IRStatus<PIR> n : newAst)
{
try
{
javaGen.getIRGenerator().applyPartialTransformation(n, normaliser);
} catch (org.overture.codegen.ir.analysis.AnalysisException e)
{
log.error("Problem normalising state designators: "
+ e.getMessage());
e.printStackTrace();
}
}
return normaliser.getStateDesInfo();
}
@Override
public void quoteClassesProduced(List<ADefaultClassDeclIR> quoteClasses)
{
for (ADefaultClassDeclIR qc : quoteClasses)
{
// Code generated quotes are represented as singletons and by default the instance
// field is null. So we'll mark quote classes as nullable_by_default.
// Example from class represented <A>: private static AQuote instance = null;
annotator.makeNullableByDefault(qc);
addVdmToJmlRuntimeImport(qc);
}
}
public JmlSettings getJmlSettings()
{
return jmlSettings;
}
public void setJmlSettings(JmlSettings jmlSettings)
{
this.jmlSettings = jmlSettings;
}
public IRSettings getIrSettings()
{
return javaGen.getSettings();
}
public void setIrSettings(IRSettings irSettings)
{
javaGen.setSettings(irSettings);
}
public JavaSettings getJavaSettings()
{
return javaGen.getJavaSettings();
}
public void setJavaSettings(JavaSettings javaSettings)
{
javaGen.setJavaSettings(javaSettings);
}
public JmlAnnotationHelper getAnnotator()
{
return annotator;
}
public JavaCodeGen getJavaGen()
{
return javaGen;
}
public JmlGenUtil getUtil()
{
return util;
}
public List<NamedTypeInfo> getTypeInfoList()
{
return typeInfoList;
}
public ADefaultClassDeclIR getInvChecksFlagOwner()
{
return invChecksFlagOwner;
}
public StateDesInfo getStateDesInfo()
{
return stateDesInfo;
}
}