예제 #1
0
  private List<PExp> extractAssumptionsFromParameter(ProgParameterSymbol p) {
    List<PExp> resultingAssumptions = new ArrayList<>();
    if (p.getDeclaredType() instanceof ProgNamedType) {

      // both PTFamily AND PTRepresentation are a PTNamed
      ProgNamedType declaredType = (ProgNamedType) p.getDeclaredType();
      PExp exemplar = declaredType.getExemplarAsPSymbol();
      if (declaredType instanceof ProgFamilyType) {
        PExp constraint = ((ProgFamilyType) declaredType).getConstraint();

        constraint = constraint.substitute(getSpecializationsForFacility(p.getTypeQualifier()));
        resultingAssumptions.add(
            constraint.substitute(
                declaredType.getExemplarAsPSymbol(),
                p.asPSymbol())); // ASSUME TC (type constraint -- since we're conceptual)
      } else if (declaredType instanceof PTRepresentation) {
        ProgReprTypeSymbol repr = ((PTRepresentation) declaredType).getReprTypeSymbol();
        PExp convention = repr.getConvention();

        resultingAssumptions.add(
            convention.substitute(declaredType.getExemplarAsPSymbol(), p.asPSymbol()));
        // ASSUME RC (repr convention -- since we're a repr)
        resultingAssumptions.add(repr.getCorrespondence());
      }
    } else { // PTGeneric
      //    resultingAssumptions.add(g.formInitializationPredicate(
      //            p.getDeclaredType(), p.getName()));
    }
    return resultingAssumptions;
  }
예제 #2
0
  private List<PExp> extractConsequentsFromParameter(ProgParameterSymbol p) {
    List<PExp> result = new ArrayList<>();
    PExp incParamExp = new PSymbolBuilder(p.asPSymbol()).incoming(true).build();
    PExp paramExp = new PSymbolBuilder(p.asPSymbol()).incoming(false).build();

    if (p.getDeclaredType() instanceof ProgNamedType) {
      ProgNamedType t = (ProgNamedType) p.getDeclaredType();
      PExp exemplar = new PSymbolBuilder(t.getExemplarName()).mathClssfctn(t.toMath()).build();

      if (t instanceof PTRepresentation) {
        ProgReprTypeSymbol repr = ((PTRepresentation) t).getReprTypeSymbol();

        PExp convention = repr.getConvention();
        PExp corrFnExp = repr.getCorrespondence();
        result.add(convention.substitute(t.getExemplarAsPSymbol(), paramExp));
      }
      if (p.getMode() == ParameterMode.PRESERVES || p.getMode() == ParameterMode.RESTORES) {
        PExp equalsExp =
            g.formEquals(paramExp, incParamExp)
                .withVCInfo(
                    p.getDefiningTree().getStart(),
                    "Ensure parameter " + p.getName() + " is restored");
        result.add(equalsExp);
      } else if (p.getMode() == ParameterMode.CLEARS) {
        PExp init =
            ((ProgNamedType) p.getDeclaredType())
                .getInitializationEnsures()
                .substitute(exemplar, paramExp);
        result.add(init);
      }
    }
    return result;
  }
예제 #3
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);
  }
예제 #4
0
  @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());
  }
예제 #5
0
  private void confirmParameterConsequentsForBlock(
      VCAssertiveBlockBuilder block, ProgParameterSymbol p) {
    PExp incParamExp = new PSymbolBuilder(p.asPSymbol()).incoming(true).build();
    PExp paramExp = new PSymbolBuilder(p.asPSymbol()).incoming(false).build();

    if (p.getDeclaredType() instanceof ProgNamedType) {
      ProgNamedType t = (ProgNamedType) p.getDeclaredType();
      PExp exemplar = new PSymbolBuilder(t.getExemplarName()).mathClssfctn(t.toMath()).build();

      if (t instanceof PTRepresentation) {
        ProgReprTypeSymbol repr = ((PTRepresentation) t).getReprTypeSymbol();

        PExp convention = repr.getConvention();
        PExp corrFnExp = repr.getCorrespondence();
        // if we're doing this its going to be on a procedure decl or op-proc decl, so just
        // say block.definingTree
        PExp newConvention =
            convention
                .substitute(t.getExemplarAsPSymbol(), paramExp)
                .withVCInfo(block.definingTree.getStart(), "Convention for " + t.getName());
        block.confirm(block.definingTree, newConvention);
      }
      if (p.getMode() == ParameterMode.PRESERVES || p.getMode() == ParameterMode.RESTORES) {
        PExp equalsExp =
            g.formEquals(paramExp, incParamExp)
                .withVCInfo(
                    block.definingTree.getStart(),
                    "Ensure parameter " + p.getName() + " is restored");
        block.confirm(block.definingTree, equalsExp);
      } else if (p.getMode() == ParameterMode.CLEARS) {
        PExp init =
            ((ProgNamedType) p.getDeclaredType())
                .getInitializationEnsures()
                .substitute(exemplar, paramExp);
        // result.add(init);
      }
    }
  }
예제 #6
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);
  }
예제 #7
0
 // The only way I'm current aware of a local requires clause getting changed
 // is by passing a locally defined type  to an operation (something of type
 // PTRepresentation). This method won't do anything otherwise.
 @NotNull
 private PExp perParameterCorrFnExpSubstitute(
     @NotNull List<ProgParameterSymbol> params, @Nullable PExp requiresOrEnsures) {
   List<PExp> result = new ArrayList<>();
   PExp resultingClause = requiresOrEnsures;
   for (ProgParameterSymbol p : params) {
     if (p.getDeclaredType() instanceof PTRepresentation) {
       ProgReprTypeSymbol repr = ((PTRepresentation) p.getDeclaredType()).getReprTypeSymbol();
       PExp corrFnExp = repr.getCorrespondence();
       // distribute conc.X into the clause passed
       Map<PExp, PExp> concReplMapping = new HashMap<>();
       concReplMapping.put(repr.exemplarAsPSymbol(), repr.conceptualExemplarAsPSymbol());
       concReplMapping.put(repr.exemplarAsPSymbol(true), repr.conceptualExemplarAsPSymbol(true));
       resultingClause = resultingClause.substitute(concReplMapping);
     }
   }
   return resultingClause == null ? g.getTrueExp() : resultingClause;
 }
예제 #8
0
 @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());
 }