package org.overture.pog.visitors;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.overture.ast.analysis.AnalysisException;
import org.overture.ast.analysis.QuestionAnswerAdaptor;
import org.overture.ast.definitions.AAssignmentDefinition;
import org.overture.ast.definitions.AClassClassDefinition;
import org.overture.ast.definitions.AClassInvariantDefinition;
import org.overture.ast.definitions.AEqualsDefinition;
import org.overture.ast.definitions.AExplicitFunctionDefinition;
import org.overture.ast.definitions.AExplicitOperationDefinition;
import org.overture.ast.definitions.AImplicitFunctionDefinition;
import org.overture.ast.definitions.AImplicitOperationDefinition;
import org.overture.ast.definitions.AInstanceVariableDefinition;
import org.overture.ast.definitions.APerSyncDefinition;
import org.overture.ast.definitions.AStateDefinition;
import org.overture.ast.definitions.ATypeDefinition;
import org.overture.ast.definitions.AValueDefinition;
import org.overture.ast.definitions.PDefinition;
import org.overture.ast.definitions.SClassDefinition;
import org.overture.ast.definitions.traces.PTraceCoreDefinition;
import org.overture.ast.definitions.traces.PTraceDefinition;
import org.overture.ast.expressions.ANotYetSpecifiedExp;
import org.overture.ast.expressions.PExp;
import org.overture.ast.lex.LexNameList;
import org.overture.ast.node.INode;
import org.overture.ast.patterns.AIdentifierPattern;
import org.overture.ast.patterns.AIgnorePattern;
import org.overture.ast.patterns.APatternListTypePair;
import org.overture.ast.patterns.ASeqBind;
import org.overture.ast.patterns.ASetBind;
import org.overture.ast.patterns.PPattern;
import org.overture.ast.statements.ANotYetSpecifiedStm;
import org.overture.ast.typechecker.NameScope;
import org.overture.ast.types.AFunctionType;
import org.overture.ast.types.AOperationType;
import org.overture.ast.types.AUnionType;
import org.overture.ast.types.PType;
import org.overture.ast.util.PTypeSet;
import org.overture.pog.contexts.AssignmentContext;
import org.overture.pog.contexts.OpBodyEndContext;
import org.overture.pog.contexts.POFunctionDefinitionContext;
import org.overture.pog.contexts.POFunctionResultContext;
import org.overture.pog.contexts.POImpliesContext;
import org.overture.pog.contexts.PONameContext;
import org.overture.pog.contexts.POOperationDefinitionContext;
import org.overture.pog.obligation.FunctionPostCondition;
import org.overture.pog.obligation.OperationPostConditionObligation;
import org.overture.pog.obligation.ParameterPatternObligation;
import org.overture.pog.obligation.ProofObligationList;
import org.overture.pog.obligation.SatisfiabilityObligation;
import org.overture.pog.obligation.SeqMembershipObligation;
import org.overture.pog.obligation.SetMembershipObligation;
import org.overture.pog.obligation.StateInvariantObligation;
import org.overture.pog.obligation.TypeCompatibilityObligation;
import org.overture.pog.obligation.ValueBindingObligation;
import org.overture.pog.pub.IPOContextStack;
import org.overture.pog.pub.IPogAssistantFactory;
import org.overture.pog.pub.IProofObligationList;
import org.overture.pog.utility.POException;
import org.overture.pog.utility.PogAssistantFactory;
import org.overture.pog.utility.UniqueNameGenerator;
public class PogParamDefinitionVisitor<Q extends IPOContextStack, A extends IProofObligationList>
extends QuestionAnswerAdaptor<IPOContextStack, IProofObligationList>
{
final private QuestionAnswerAdaptor<IPOContextStack, ? extends IProofObligationList> rootVisitor;
final private QuestionAnswerAdaptor<IPOContextStack, ? extends IProofObligationList> mainVisitor;
final protected IPogAssistantFactory assistantFactory;
/**
* Constructor for Extensions.
*
* @param parentVisitor
* @param mainVisitor
* @param assistantFactory
*/
public PogParamDefinitionVisitor(
QuestionAnswerAdaptor<IPOContextStack, ? extends IProofObligationList> parentVisitor,
QuestionAnswerAdaptor<IPOContextStack, ? extends IProofObligationList> mainVisitor,
IPogAssistantFactory assistantFactory)
{
this.rootVisitor = parentVisitor;
this.mainVisitor = mainVisitor;
this.assistantFactory = assistantFactory;
}
/**
* Overture constructor. <b>NOT</b> for use by extensions.
*
* @param parentVisitor
*/
public PogParamDefinitionVisitor(
QuestionAnswerAdaptor<IPOContextStack, ? extends IProofObligationList> parentVisitor)
{
this.rootVisitor = parentVisitor;
this.mainVisitor = this;
this.assistantFactory = new PogAssistantFactory();
}
@Override
// from [1] pg. 35 we have an:
// explicit function definition = identifier,
// [ type variable list ], �:�, function type,
// identifier, parameters list, �==�,
// function body,
// [ �pre�, expression ],
// [ �post�, expression ],
// [ �measure�, name ] ;
public IProofObligationList caseAExplicitFunctionDefinition(
AExplicitFunctionDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
// skip not yet specified
if (node.getBody() instanceof ANotYetSpecifiedExp)
{
return new ProofObligationList();
}
// Insanely, we can call operations in functions so let's set it up...
question.setGenerator(new UniqueNameGenerator(node));
IProofObligationList obligations = new ProofObligationList();
LexNameList pids = new LexNameList();
// add all defined names from the function parameter list
boolean alwaysMatches = true;
for (List<PPattern> params : node.getParamPatternList())
{
alwaysMatches = params.isEmpty() && alwaysMatches;
}
if (alwaysMatches)
{
// no arguments. skip to next
} else
{
alwaysMatches = true;
PatternAlwaysMatchesVisitor amVisitor = new PatternAlwaysMatchesVisitor();
for (List<PPattern> patterns : node.getParamPatternList())
{
for (PPattern p : patterns)
{
for (PDefinition def : p.getDefinitions())
{
pids.add(def.getName());
}
alwaysMatches = alwaysMatches && p.apply(amVisitor);
}
}
}
// check for duplicates
if (pids.hasDuplicates() || !alwaysMatches)
{
obligations.add(new ParameterPatternObligation(node, question, assistantFactory));
}
// do proof obligations for the pre-condition
PExp precondition = node.getPrecondition();
if (precondition != null)
{
question.push(new POFunctionDefinitionContext(node, false));
obligations.addAll(precondition.apply(rootVisitor, question));
question.pop();
}
// do proof obligations for the post-condition
PExp postcondition = node.getPostcondition();
if (postcondition != null)
{
question.push(new POFunctionDefinitionContext(node, false));
obligations.add(new FunctionPostCondition(node, question, assistantFactory));
question.push(new POFunctionResultContext(node));
obligations.addAll(postcondition.apply(rootVisitor, question));
question.pop();
question.pop();
}
// do proof obligations for the function body
question.push(new POFunctionDefinitionContext(node, true));
PExp body = node.getBody();
obligations.addAll(body.apply(rootVisitor, question));
// do proof obligation for the return type
if (node.getIsUndefined()
|| !assistantFactory.getTypeComparator().isSubType(node.getActualResult(), node.getExpectedResult()))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(node, node.getExpectedResult(), node.getActualResult(), question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
question.pop();
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList defaultSClassDefinition(SClassDefinition node,
IPOContextStack question) throws AnalysisException
{
try
{
IProofObligationList proofObligationList = new ProofObligationList();
for (PDefinition def : node.getDefinitions())
{
proofObligationList.addAll(def.apply(mainVisitor, question));
}
return proofObligationList;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAClassInvariantDefinition(
AClassInvariantDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
IProofObligationList list = new ProofObligationList();
if (!node.getClassDefinition().getHasContructors())
{
for (PDefinition pdef : node.getClassDefinition().getDefinitions())
{
if (pdef instanceof AInstanceVariableDefinition)
{
AInstanceVariableDefinition ivdef = (AInstanceVariableDefinition) pdef;
if (ivdef.getInitialized())
{
question.push(new AssignmentContext((AInstanceVariableDefinition) pdef, assistantFactory.getVarSubVisitor(), question));
}
}
}
list.add(new StateInvariantObligation(node, question, assistantFactory));
question.clearStateContexts();
list.add(new SatisfiabilityObligation(node, question, assistantFactory));
}
return list;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAEqualsDefinition(AEqualsDefinition node,
IPOContextStack question) throws AnalysisException
{
try
{
IProofObligationList list = new ProofObligationList();
PPattern pattern = node.getPattern();
if (pattern != null)
{
if (!(pattern instanceof AIdentifierPattern)
&& !(pattern instanceof AIgnorePattern)
&& node.getExpType() instanceof AUnionType)
{
PType patternType = assistantFactory.createPPatternAssistant().getPossibleType(pattern); // With
// unknowns
AUnionType ut = (AUnionType) node.getExpType();
PTypeSet set = new PTypeSet(assistantFactory);
for (PType u : ut.getTypes())
{
if (assistantFactory.getTypeComparator().compatible(u, patternType))
{
set.add(u);
}
}
if (!set.isEmpty())
{
PType compatible = set.getType(node.getLocation());
if (!assistantFactory.getTypeComparator().isSubType(question.checkType(node.getTest(), node.getExpType()), compatible))
{
list.add(new ValueBindingObligation(node, question, assistantFactory));
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(node.getTest(), compatible, node.getExpType(), question, assistantFactory);
if (sto != null)
{
list.add(sto);
}
}
}
}
}
else if (node.getTypebind() != null)
{
if (!assistantFactory.getTypeComparator().isSubType(question.checkType(node.getTest(), node.getExpType()), node.getDefType()))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(node.getTest(), node.getDefType(), node.getExpType(), question, assistantFactory);
if (sto != null)
{
list.add(sto);
}
}
}
else if (node.getSetbind() != null)
{
ASetBind bind = node.getSetbind();
list.addAll(bind.getSet().apply(rootVisitor, question));
list.add(new SetMembershipObligation(bind.getPattern(), bind.getSet(), question, assistantFactory));
}
else if (node.getSeqbind() != null)
{
ASeqBind bind = node.getSeqbind();
list.addAll(bind.getSeq().apply(rootVisitor, question));
list.add(new SeqMembershipObligation(bind.getPattern(), bind.getSeq(), question, assistantFactory));
}
list.addAll(node.getTest().apply(rootVisitor, question));
return list;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAImplicitFunctionDefinition(
AImplicitFunctionDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
IProofObligationList obligations = new ProofObligationList();
LexNameList pids = new LexNameList();
AFunctionType ftype = (AFunctionType) node.getType();
Iterator<PType> typeIter = ftype.getParameters().iterator();
boolean alwaysMatches;
alwaysMatches = true;
PatternAlwaysMatchesVisitor amVisitor = new PatternAlwaysMatchesVisitor();
for (APatternListTypePair pltp : node.getParamPatterns())
{
for (PPattern p : pltp.getPatterns())
{
for (PDefinition def : assistantFactory.createPPatternAssistant().getDefinitions(p, typeIter.next(), NameScope.LOCAL))
{
pids.add(def.getName());
}
alwaysMatches = alwaysMatches && p.apply(amVisitor);
}
}
if (pids.hasDuplicates() || !alwaysMatches)
{
obligations.add(new ParameterPatternObligation(node, question, assistantFactory));
}
// I pass one more argument to the method
// POFunctionDefinitionContext to pass the assistantFactory.
question.push(new POFunctionDefinitionContext(node, false, assistantFactory));
if (node.getPrecondition() != null)
{
obligations.addAll(node.getPrecondition().apply(rootVisitor, question));
}
if (node.getPostcondition() != null)
{
if (node.getBody() != null) // else satisfiability, below
{
obligations.add(new FunctionPostCondition(node, question, assistantFactory));
}
question.push(new POFunctionResultContext(node));
obligations.addAll(node.getPostcondition().apply(rootVisitor, question));
question.pop();
}
if (node.getBody() == null)
{
if (node.getPostcondition() != null)
{
obligations.add(new SatisfiabilityObligation(node, question, assistantFactory));
}
} else
{
obligations.addAll(node.getBody().apply(rootVisitor, question));
if (node.getIsUndefined()
|| !assistantFactory.getTypeComparator().isSubType(node.getActualResult(), ((AFunctionType) node.getType()).getResult()))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(node, ((AFunctionType) node.getType()).getResult(), node.getActualResult(), question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
}
question.pop();
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAExplicitOperationDefinition(
AExplicitOperationDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
if (node.getBody() instanceof ANotYetSpecifiedStm)
{
return new ProofObligationList();
}
question.setGenerator(new UniqueNameGenerator(node));
IProofObligationList obligations = new ProofObligationList();
LexNameList pids = new LexNameList();
Boolean precond = true;
if (node.getPrecondition() == null)
{
precond = false;
}
collectOpCtxt(node, question, precond);
// add all defined names from the function parameter list
AOperationType otype = (AOperationType) node.getType();
Iterator<PType> typeIter = otype.getParameters().iterator();
boolean alwaysMatches = true;
PatternAlwaysMatchesVisitor amVisitor = new PatternAlwaysMatchesVisitor();
for (PPattern p : node.getParameterPatterns())
{
for (PDefinition def : assistantFactory.createPPatternAssistant().getDefinitions(p, typeIter.next(), NameScope.LOCAL))
{
pids.add(def.getName());
}
alwaysMatches = alwaysMatches && p.apply(amVisitor);
}
if (pids.hasDuplicates() || !alwaysMatches)
{
obligations.add(new ParameterPatternObligation(node, question, assistantFactory));
}
if (node.getPrecondition() != null)
{
obligations.addAll(node.getPrecondition().apply(rootVisitor, question));
}
obligations.addAll(node.getBody().apply(rootVisitor, question));
if (node.getIsConstructor() && node.getClassDefinition() != null
&& node.getClassDefinition().getInvariant() != null)
{
obligations.add(new StateInvariantObligation(node, question, assistantFactory));
}
if (!node.getIsConstructor()
&& !assistantFactory.getTypeComparator().isSubType(node.getActualResult(), ((AOperationType) node.getType()).getResult()))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(node, node.getActualResult(), question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
if (node.getPostcondition() != null)
{
List<AInstanceVariableDefinition> state = collectState(node);
question.push(new OpBodyEndContext(state, assistantFactory));
obligations.addAll(node.getPostcondition().apply(rootVisitor, question));
obligations.add(new OperationPostConditionObligation(node, question, assistantFactory));
}
question.clearStateContexts();
question.pop();
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
protected List<AInstanceVariableDefinition> collectState(
AExplicitOperationDefinition node) throws AnalysisException
{
List<AInstanceVariableDefinition> r = new LinkedList<AInstanceVariableDefinition>();
List<PDefinition> stateDefs;
if (node.getClassDefinition() != null)
{
stateDefs = node.getClassDefinition().getDefinitions();
} else
{
if (node.getState() != null)
{
stateDefs = node.getState().getStateDefs();
} else
{
return r;
}
}
for (PDefinition d : stateDefs)
{
if (d instanceof AInstanceVariableDefinition)
{
r.add((AInstanceVariableDefinition) d);
}
}
return r;
}
/**
* Operation processing is identical in extension except for context generation. So, a quick trick here.
*
* @param node
* @param question
* @param precond
* @throws AnalysisException
*/
protected void collectOpCtxt(AExplicitOperationDefinition node,
IPOContextStack question, Boolean precond) throws AnalysisException
{
question.push(new POOperationDefinitionContext(node, precond, node.getState()));
}
@Override
public IProofObligationList caseAImplicitOperationDefinition(
AImplicitOperationDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
IProofObligationList obligations = new ProofObligationList();
LexNameList pids = new LexNameList();
AOperationType otype = (AOperationType) node.getType();
Iterator<PType> typeIter = otype.getParameters().iterator();
boolean alwaysMatches = true;
PatternAlwaysMatchesVisitor amVisitor = new PatternAlwaysMatchesVisitor();
for (APatternListTypePair tp : node.getParameterPatterns())
{
for (PPattern p : tp.getPatterns())
{
for (PDefinition def : assistantFactory.createPPatternAssistant().getDefinitions(p, typeIter.next(), NameScope.LOCAL))
{
pids.add(def.getName());
}
alwaysMatches = alwaysMatches && p.apply(amVisitor);
}
}
if (pids.hasDuplicates() || !alwaysMatches)
{
obligations.add(new ParameterPatternObligation(node, question, assistantFactory));
}
if (node.getPrecondition() != null)
{
obligations.addAll(node.getPrecondition().apply(rootVisitor, question));
}
if (node.getPostcondition() != null)
{
if (node.getPrecondition() != null)
{
question.push(new POImpliesContext(node.getPrecondition()));
obligations.addAll(node.getPostcondition().apply(rootVisitor, question));
question.pop();
} else
{
obligations.addAll(node.getPostcondition().apply(rootVisitor, question));
}
}
if (node.getBody() != null)
{
obligations.addAll(node.getBody().apply(rootVisitor, question));
if (node.getIsConstructor()
&& node.getClassDefinition() != null
&& node.getClassDefinition().getInvariant() != null)
{
obligations.add(new StateInvariantObligation(node, question, assistantFactory));
}
if (!node.getIsConstructor()
&& !assistantFactory.getTypeComparator().isSubType(node.getActualResult(), ((AOperationType) node.getType()).getResult()))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(node, node.getActualResult(), question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
} else
{
if (node.getPostcondition() != null)
{
// passed 1 more argument to give the assistantFactory to
// the constructor.
question.push(new POOperationDefinitionContext(node, false, node.getStateDefinition(), assistantFactory));
obligations.add(new SatisfiabilityObligation(node, node.getStateDefinition(), question, assistantFactory));
question.pop();
}
}
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAAssignmentDefinition(
AAssignmentDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
IProofObligationList obligations = new ProofObligationList();
PExp expression = node.getExpression();
PType type = node.getType();
PType expType = node.getExpType();
obligations.addAll(expression.apply(rootVisitor, question));
if (!assistantFactory.getTypeComparator().isSubType(question.checkType(expression, expType), type))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(expression, type, expType, question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList defaultPDefinition(PDefinition node,
IPOContextStack question)
{
return new ProofObligationList();
}
public IProofObligationList caseAInstanceVariableDefinition(
AInstanceVariableDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
IProofObligationList obligations = new ProofObligationList();
PExp expression = node.getExpression();
PType type = node.getType();
PType expType = node.getExpType();
obligations.addAll(expression.apply(rootVisitor, question));
if (!assistantFactory.getTypeComparator().isSubType(question.checkType(expression, expType), type))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(expression, type, expType, question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAPerSyncDefinition(APerSyncDefinition node,
IPOContextStack question) throws AnalysisException
{
try
{
question.push(new PONameContext(new LexNameList(node.getOpname())));
IProofObligationList list = node.getGuard().apply(rootVisitor, question);
question.pop();
return list;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAStateDefinition(AStateDefinition node,
IPOContextStack question) throws AnalysisException
{
try
{
IProofObligationList list = new ProofObligationList();
if (node.getInvdef() != null)
{
list.addAll(node.getInvdef().apply(mainVisitor, question));
list.add(new SatisfiabilityObligation(node, question, assistantFactory));
}
return list;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseATypeDefinition(ATypeDefinition node,
IPOContextStack question) throws AnalysisException
{
try
{
IProofObligationList list = new ProofObligationList();
AExplicitFunctionDefinition invDef = node.getInvdef();
if (invDef != null)
{
list.addAll(invDef.apply(mainVisitor, question));
list.add(new SatisfiabilityObligation(node, question, assistantFactory));
}
return list;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList caseAValueDefinition(AValueDefinition node,
IPOContextStack question) throws AnalysisException
{
try
{
IProofObligationList obligations = new ProofObligationList();
PExp exp = node.getExpression();
obligations.addAll(exp.apply(rootVisitor, question));
PPattern pattern = node.getPattern();
PType type = node.getType();
if (!(pattern instanceof AIdentifierPattern)
&& !(pattern instanceof AIgnorePattern)
&& assistantFactory.createPTypeAssistant().isUnion(type))
{
PType patternType = assistantFactory.createPPatternAssistant().getPossibleType(pattern);
AUnionType ut = assistantFactory.createPTypeAssistant().getUnion(type);
PTypeSet set = new PTypeSet(assistantFactory);
for (PType u : ut.getTypes())
{
if (assistantFactory.getTypeComparator().compatible(u, patternType))
{
set.add(u);
}
}
if (!set.isEmpty())
{
PType compatible = set.getType(node.getLocation());
if (!assistantFactory.getTypeComparator().isSubType(type, compatible))
{
obligations.add(new ValueBindingObligation(node, question, assistantFactory));
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(exp, compatible, type, question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
}
}
if (!assistantFactory.getTypeComparator().isSubType(question.checkType(exp, node.getExpType()), type))
{
TypeCompatibilityObligation sto = TypeCompatibilityObligation.newInstance(exp, type, node.getExpType(), question, assistantFactory);
if (sto != null)
{
obligations.add(sto);
}
}
return obligations;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList defaultPTraceDefinition(PTraceDefinition node,
IPOContextStack question)
{
return new ProofObligationList();
}
@Override
public IProofObligationList defaultPTraceCoreDefinition(
PTraceCoreDefinition node, IPOContextStack question)
{
return new ProofObligationList();
}
@Override
public IProofObligationList caseAClassClassDefinition(
AClassClassDefinition node, IPOContextStack question)
throws AnalysisException
{
try
{
IProofObligationList proofObligationList = new ProofObligationList();
question.setGenerator(new UniqueNameGenerator(node));
for (PDefinition def : node.getDefinitions())
{
question.push(new PONameContext(assistantFactory.createPDefinitionAssistant().getVariableNames(def)));
proofObligationList.addAll(def.apply(mainVisitor, question));
question.pop();
question.clearStateContexts();
}
return proofObligationList;
} catch (Exception e)
{
throw new POException(node, e.getMessage());
}
}
@Override
public IProofObligationList createNewReturnValue(INode node,
IPOContextStack question)
{
return new ProofObligationList();
}
@Override
public IProofObligationList createNewReturnValue(Object node,
IPOContextStack question)
{
return new ProofObligationList();
}
}