@Override
public void enterFacilityDecl(ResolveParser.FacilityDeclContext ctx) {
VCAssertiveBlockBuilder block =
new VCAssertiveBlockBuilder(g, moduleScope, "Facility_Inst=" + ctx.name.getText(), ctx);
block.assume(g.getTrueExp());
assertiveBlocks.push(block);
}
@Override
public void exitCallStmt(ResolveParser.CallStmtContext ctx) {
VCRuleBackedStat s = null;
PApply callExp = (PApply) tr.exprASTs.get(ctx.progParamExp());
OperationSymbol op = getOperation(moduleScope, callExp);
if (inSimpleForm(op.getEnsures(), op.getParameters())) {
// TODO: Use log instead!
// gen.getCompiler().info("APPLYING EXPLICIT (SIMPLE) CALL RULE");
s = new VCCall(ctx, assertiveBlocks.peek(), EXPLICIT_CALL_APPLICATION, callExp);
} else {
// TODO: Use log instead!
// gen.getCompiler().info("APPLYING GENERAL CALL RULE");
s = new VCCall(ctx, assertiveBlocks.peek(), GENERAL_CALL_APPLICATION, callExp);
}
stats.put(ctx, s);
}
@Override
public void enterProcedureDecl(ResolveParser.ProcedureDeclContext ctx) {
Scope s = symtab.getScope(ctx);
try {
List<ProgParameterSymbol> paramSyms = s.getSymbolsOfType(ProgParameterSymbol.class);
currentProcOpSym =
s.queryForOne(
new OperationQuery(
null, ctx.name, Utils.apply(paramSyms, ProgParameterSymbol::getDeclaredType)));
// This is the requires for the operation with some substutions made (see corrFnExp rule in
// HH-diss)
PExp corrFnExpRequires =
perParameterCorrFnExpSubstitute(paramSyms, currentProcOpSym.getRequires());
List<PExp> opParamAntecedents = new ArrayList<>();
Utils.apply(paramSyms, opParamAntecedents, this::extractAssumptionsFromParameter);
Set<PExp> l = getModuleLevelAssertionsOfType(ClauseType.REQUIRES);
VCAssertiveBlockBuilder block =
new VCAssertiveBlockBuilder(g, s, "Correct_Op_Hypo=" + ctx.name.getText(), ctx)
.facilitySpecializations(facilitySpecFormalActualMappings)
.assume(getModuleLevelAssertionsOfType(ClauseType.REQUIRES))
// TODO: constraints should be added on demand via NOTICE:...
// .assume(getModuleLevelAssertionsOfType(ClauseType.CONSTRAINT))
.assume(opParamAntecedents) // we assume correspondence for reprs here automatically
.assume(corrFnExpRequires)
.remember();
assertiveBlocks.push(block);
} catch (SymbolTableException e) {
throw new RuntimeException(e); // this shouldn't happen now
}
}
@Override
public void exitOperationProcedureDecl(ResolveParser.OperationProcedureDeclContext ctx) {
Scope s = symtab.getScope(ctx);
VCAssertiveBlockBuilder block = assertiveBlocks.pop();
List<ProgParameterSymbol> paramSyms = s.getSymbolsOfType(ProgParameterSymbol.class);
PExp corrFnExpEnsures =
perParameterCorrFnExpSubstitute(
paramSyms,
tr.getMathExpASTFor(
g, ctx.ensuresClause())); // postcondition[params 1..i <-- corr_fn_exp]
corrFnExpEnsures =
corrFnExpEnsures.withVCInfo(ctx.getStart(), "Ensures clause of " + ctx.name.getText());
Token loc = ctx.ensuresClause() != null ? ctx.ensuresClause().getStart() : ctx.getStart();
List<PExp> paramConsequents = new ArrayList<>();
Utils.apply(paramSyms, paramConsequents, this::extractConsequentsFromParameter);
// add verification statements to the assertive context/block
block.stats(Utils.collect(VCRuleBackedStat.class, ctx.stmt(), stats));
// add any additional confirms from the parameters, etc
for (ProgParameterSymbol p : paramSyms) {
confirmParameterConsequentsForBlock(block, p); // modfies 'block' with additional confims!
}
// TODO: Tomorrow look at the verification statements in the assertive context for
// int_do_nothing, then
block.finalConfirm(corrFnExpEnsures);
outputFile.addAssertiveBlock(block.build());
}
@Override
public void exitAssignStmt(ResolveParser.AssignStmtContext ctx) {
VCRuleBackedStat s =
new VCRuleBackedStat(
ctx,
assertiveBlocks.peek(),
FUNCTION_ASSIGN_APPLICATION,
tr.exprASTs.get(ctx.left),
tr.exprASTs.get(ctx.right));
stats.put(ctx, s);
}
private List<PExp> reduceArgs(List<ParserRuleContext> args) {
List<PExp> result = new ArrayList<>();
for (ParserRuleContext arg : args) {
PExp argAsPExp = tr.getMathExpASTFor(g, arg);
if (argAsPExp instanceof PApply) { // i.e., we're dealing with a function application
PExp e = applyCallRuleToExp(arg, assertiveBlocks.peek(), (PApply) argAsPExp);
result.add(e);
} else {
result.add(argAsPExp);
}
}
return result;
}
@Override
public void enterTypeImplInit(ResolveParser.TypeImplInitContext ctx) {
Scope s = symtab.getScope(ctx.getParent());
PExp convention = currentTypeReprSym.getConvention();
PExp correspondence = currentTypeReprSym.getCorrespondence();
PExp typeInitEnsures = g.getTrueExp();
List<ModuleParameterSymbol> moduleParamSyms = getAllModuleParameterSyms();
VCAssertiveBlockBuilder block =
new VCAssertiveBlockBuilder(g, s, "T_Init_Hypo=" + currentTypeReprSym.getName(), ctx)
.assume(getModuleLevelAssertionsOfType(ClauseType.REQUIRES))
.assume(
getAssertionsFromModuleFormalParameters(
moduleParamSyms, this::extractAssumptionsFromParameter));
assertiveBlocks.push(block);
}
@Override
public void exitTypeImplInit(ResolveParser.TypeImplInitContext ctx) {
PExp typeInitEnsures = g.getTrueExp();
PExp convention = currentTypeReprSym.getConvention();
PExp correspondence = currentTypeReprSym.getCorrespondence();
if (currentTypeReprSym.getDefinition() != null) {
typeInitEnsures =
currentTypeReprSym.getDefinition().getProgramType().getInitializationEnsures();
}
VCAssertiveBlockBuilder block = assertiveBlocks.pop();
PExp newInitEnsures =
typeInitEnsures.substitute(
currentTypeReprSym.exemplarAsPSymbol(),
currentTypeReprSym.conceptualExemplarAsPSymbol());
// block.stats(Utils.collect(VCRuleBackedStat.class, ctx.stmt(), stats));
// block.confirm(convention); //order here is important
block.assume(correspondence);
throw new UnsupportedOperationException("re-institute the final confirm for this dan");
// block.finalConfirm(newInitEnsures, "Initialization-ensures clause of " +
// currentTypeReprSym.getName());
// outputFile.addAssertiveBlock(block.build());
}
@Override
public void exitTypeRepresentationDecl(ResolveParser.TypeRepresentationDeclContext ctx) {
PExp constraint = g.getTrueExp();
PExp correspondence = g.getTrueExp();
if (currentTypeReprSym == null) return;
correspondence = currentTypeReprSym.getCorrespondence();
if (currentTypeReprSym.getDefinition() != null) {
constraint = currentTypeReprSym.getDefinition().getProgramType().getConstraint();
}
VCAssertiveBlockBuilder block = assertiveBlocks.pop();
PExp newConstraint =
constraint.substitute(
currentTypeReprSym.exemplarAsPSymbol(),
currentTypeReprSym.conceptualExemplarAsPSymbol());
newConstraint =
newConstraint.withVCInfo(ctx.getStart(), "Constraint for type: " + ctx.name.getText());
block.assume(correspondence.splitIntoConjuncts());
// throw new UnsupportedOperationException("re-institute the final confirm for this dan");
block.finalConfirm(newConstraint);
outputFile.addAssertiveBlock(block.build());
}
@Override
public void enterTypeRepresentationDecl(ResolveParser.TypeRepresentationDeclContext ctx) {
Scope s = symtab.getScope(ctx);
currentTypeReprSym = null;
try {
currentTypeReprSym =
moduleScope
.queryForOne(new UnqualifiedNameQuery(ctx.name.getText()))
.toProgReprTypeSymbol();
} catch (SymbolTableException e) {
}
List<PExp> opParamAntecedents =
getAssertionsFromModuleFormalParameters(
getAllModuleParameterSyms(), this::extractAssumptionsFromParameter);
VCAssertiveBlockBuilder block =
new VCAssertiveBlockBuilder(g, s, "Well_Def_Corr_Hyp=" + ctx.name.getText(), ctx)
.assume(opParamAntecedents)
.assume(getModuleLevelAssertionsOfType(ClauseType.REQUIRES))
.assume(currentTypeReprSym.getConvention());
assertiveBlocks.push(block);
}
@Override
public void exitProcedureDecl(ResolveParser.ProcedureDeclContext ctx) {
Scope scope = symtab.getScope(ctx);
List<ProgParameterSymbol> paramSyms = scope.getSymbolsOfType(ProgParameterSymbol.class);
VCAssertiveBlockBuilder block = assertiveBlocks.pop();
List<ProgParameterSymbol> formalParameters = new ArrayList<>();
try {
formalParameters =
scope.query(new SymbolTypeQuery<ProgParameterSymbol>(ProgParameterSymbol.class));
} catch (NoSuchModuleException | UnexpectedSymbolException e) {
e.printStackTrace();
}
List<PExp> corrFnExps =
paramSyms
.stream()
.filter(p -> p.getDeclaredType() instanceof PTRepresentation)
.map(p -> (PTRepresentation) p.getDeclaredType())
.map(p -> p.getReprTypeSymbol().getCorrespondence())
.collect(Collectors.toList());
PExp corrFnExpEnsures =
perParameterCorrFnExpSubstitute(paramSyms, currentProcOpSym.getEnsures())
.withVCInfo(ctx.getStart(), "Ensures clause of " + ctx.name.getText());
// postcondition[params 1..i <-- corr_fn_exp]
List<PExp> paramConsequents = new ArrayList<>();
Utils.apply(formalParameters, paramConsequents, this::extractConsequentsFromParameter);
block
.stats(Utils.collect(VCRuleBackedStat.class, ctx.stmt(), stats))
.assume(corrFnExps)
.confirm(ctx, g.formConjuncts(paramConsequents))
.finalConfirm(corrFnExpEnsures);
outputFile.addAssertiveBlock(block.build());
currentProcOpSym = null;
}
// TODO: Would be really cool if we could hover over a given and get information about where it
// came from
// "constraint for type Integer", etc.
@Override
public void enterOperationProcedureDecl(ResolveParser.OperationProcedureDeclContext ctx) {
Scope s = symtab.getScope(ctx);
List<ProgParameterSymbol> paramSyms = s.getSymbolsOfType(ProgParameterSymbol.class);
// precondition[params 1..i <-- conc.X]
PExp corrFnExpRequires =
perParameterCorrFnExpSubstitute(paramSyms, tr.getMathExpASTFor(g, ctx.requiresClause()));
VCAssertiveBlockBuilder block =
new VCAssertiveBlockBuilder(g, s, "Proc_Decl_rule=" + ctx.name.getText(), ctx)
.facilitySpecializations(facilitySpecFormalActualMappings)
.assume(
getAssertionsFromModuleFormalParameters(
getAllModuleParameterSyms(), this::extractAssumptionsFromParameter))
.assume(
getAssertionsFromFormalParameters(paramSyms, this::extractAssumptionsFromParameter))
.assume(getModuleLevelAssertionsOfType(ClauseType.REQUIRES))
.assume(getModuleLevelAssertionsOfType(ClauseType.CONSTRAINT))
.assume(corrFnExpRequires)
.remember();
assertiveBlocks.push(block);
}