コード例 #1
0
 public ModelBuilderProto(VCGenerator gen, MathSymbolTable symtab) {
   this.symtab = symtab;
   this.tr = gen.getModule();
   this.g = symtab.getTypeGraph();
   this.gen = gen;
   this.outputFile = new VCOutputFile(gen.getCompiler());
 }
コード例 #2
0
  @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
    }
  }
コード例 #3
0
  @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());
  }
コード例 #4
0
 @Override
 public void enterModuleDecl(ResolveParser.ModuleDeclContext ctx) {
   try {
     moduleScope = symtab.getModuleScope(tr.getModuleIdentifier());
   } catch (NoSuchModuleException e) { // shouldn't happen, but eh.
     gen.getCompiler().errMgr.semanticError(ErrorKind.NO_SUCH_MODULE, Utils.getModuleCtxName(ctx));
   }
 }
コード例 #5
0
 public List<ModuleParameterSymbol> getAllModuleParameterSyms() {
   List<ModuleParameterSymbol> result = moduleScope.getSymbolsOfType(ModuleParameterSymbol.class);
   for (ModuleIdentifier e : moduleScope.getInheritedIdentifiers()) {
     try {
       ModuleScopeBuilder s = symtab.getModuleScope(e);
       result.addAll(s.getSymbolsOfType(ModuleParameterSymbol.class));
     } catch (NoSuchModuleException e1) { // should've been caught a long time ago
       throw new RuntimeException(e1);
     }
   }
   return result;
 }
コード例 #6
0
  @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);
  }
コード例 #7
0
  @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);
  }
コード例 #8
0
  @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;
  }
コード例 #9
0
  // 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);
  }