public void markUsed(List<PDefinition> definitions) { for (PDefinition d : definitions) { af.createPDefinitionAssistant().markUsed(d); } }
public Collection<? extends PDefinition> getDefinitions( AModuleExports aModuleExports, LinkedList<PDefinition> actualDefs) { List<PDefinition> exportDefs = new Vector<PDefinition>(); for (List<PExport> etype : aModuleExports.getExports()) { for (PExport exp : etype) { exportDefs.addAll(getDefinition(exp, actualDefs)); } } // Mark all exports as used for (PDefinition d : exportDefs) { af.createPDefinitionAssistant().markUsed(d); } return exportDefs; }
public Collection<? extends PDefinition> getDefinitions( AModuleExports aModuleExports) { List<PDefinition> exportDefs = new Vector<PDefinition>(); for (List<PExport> etype : aModuleExports.getExports()) { for (PExport exp : etype) { exportDefs.addAll(getDefinition(exp)); } } // Mark all exports as used for (PDefinition d : exportDefs) { af.createPDefinitionAssistant().markUsed(d); } return exportDefs; }
@Override public PDefinition caseAImportedDefinition(AImportedDefinition node, Newquestion question) throws AnalysisException { PDefinition def = node.getDef().apply(this, question);// PDefinitionAssistantTC.findName(d.getDef(), sought, // scope); if (def != null) { af.createPDefinitionAssistant().markUsed(node); } return def; }
public List<PDefinition> getTypeParamDefinitions( AExplicitFunctionDefinition node) { List<PDefinition> defs = new ArrayList<PDefinition>(); for (ILexNameToken pname : node.getTypeParams()) { PDefinition p = AstFactory.newALocalDefinition(pname.getLocation(), pname.clone(), NameScope.NAMES, AstFactory.newAParameterType(pname.clone())); // pname.location, NameScope.NAMES,false,null, null, new // AParameterType(null,false,null,pname.clone()),false,pname.clone()); af.createPDefinitionAssistant().markUsed(p); defs.add(p); } return defs; }
public List<PDefinition> getTypeParamDefinitions( AImplicitFunctionDefinition node) { List<PDefinition> defs = new ArrayList<PDefinition>(); for (ILexNameToken pname : node.getTypeParams()) { PDefinition p = AstFactory.newALocalDefinition(pname.getLocation(), pname.clone(), NameScope.NAMES, AstFactory.newAParameterType(pname.clone())); // new ALocalDefinition( // pname.location, NameScope.NAMES,false,null, null, new // AParameterType(null,false,null,pname.clone()),false,pname.clone()); af.createPDefinitionAssistant().markUsed(p); defs.add(p); } return defs; }
@Override public PDefinition caseARenamedDefinition(ARenamedDefinition node, Newquestion question) throws AnalysisException { PDefinition renamed = af.createPDefinitionAssistant().findNameBaseCase(node, question.sought, question.scope); if (renamed != null) { af.createPDefinitionAssistant().markUsed(node.getDef()); return renamed; } else { // Renamed definitions hide the original name return null;// PDefinitionAssistantTC.findName(d.getDef(),sought, scope); } }
public void unusedCheckBaseCase(PDefinition d) { if (!af.createPDefinitionAssistant().isUsed(d)) { TypeCheckerErrors.warning(5000, "Definition '" + d.getName() + "' not used", d.getLocation(), d); markUsed(d); // To avoid multiple warnings } }
@Override public PDefinition caseAImportedDefinition(AImportedDefinition node, Newquestion question) throws AnalysisException { // We can only find an import if it is being sought from the module that // imports it. if (question.fromModule != null && !node.getLocation().getModule().equals(question.fromModule)) { return null; // Someone else's import } PDefinition def = af.createPDefinitionAssistant().findType(node.getDef(), question.sought, question.fromModule); if (def != null) { af.createPDefinitionAssistant().markUsed(node); } return def; }
@Override public List<PDefinition> caseAAllImport(AAllImport imp, AModuleModules module) throws AnalysisException { // return AAllImportAssistantTC.getDefinitions(imp,from); imp.setFrom(module); if (imp.getFrom().getExportdefs().isEmpty()) { TypeCheckerErrors.report(3190, "Import all from module with no exports?", imp.getLocation(), imp); } List<PDefinition> imported = new Vector<PDefinition>(); for (PDefinition d : imp.getFrom().getExportdefs()) { PDefinition id = AstFactory.newAImportedDefinition(imp.getLocation(), d); af.createPDefinitionAssistant().markUsed(id); // So imports all is quiet imported.add(id); } return imported; // The lot! }
@Override public PDefinition defaultSClassDefinition(SClassDefinition classDefinition) throws AnalysisException { PDefinition def = AstFactory.newALocalDefinition(classDefinition.getLocation(), classDefinition.getName().getSelfName(), NameScope.LOCAL, af.createPDefinitionAssistant().getType(classDefinition)); af.createPDefinitionAssistant().markUsed(def); return def; }
@Override public void caseAExplicitOperationDefinition( AExplicitOperationDefinition node, Environment question) throws AnalysisException { node.setState(findStateDefinition(question, node)); if (node.getPrecondition() != null) { node.setPredef(af.createAExplicitOperationDefinitionAssistant().getPreDefinition(node, question)); af.createPDefinitionAssistant().markUsed(node.getPredef()); // ORIGINAL CODE } if (node.getPostcondition() != null) { node.setPostdef(af.createAExplicitOperationDefinitionAssistant().getPostDefinition(node, question)); af.createPDefinitionAssistant().markUsed(node.getPostdef()); } }
@Override public void caseAImplicitOperationDefinition( AImplicitOperationDefinition node, Environment question) throws AnalysisException { node.setState(findStateDefinition(question, node)); if (node.getPrecondition() != null) { node.setPredef(af.createAImplicitOperationDefinitionAssistant().getPreDefinition(node, question)); af.createPDefinitionAssistant().markUsed(node.getPredef()); } if (node.getPostcondition() != null) { node.setPostdef(af.createAImplicitOperationDefinitionAssistant().getPostDefinition(node, question)); af.createPDefinitionAssistant().markUsed(node.getPostdef()); } }
@Override public PDefinition caseARenamedDefinition(ARenamedDefinition node, Newquestion question) throws AnalysisException { // We can only find an import if it is being sought from the module that // imports it. if (question.fromModule != null && !node.getLocation().getModule().equals(question.fromModule)) { return null; // Someone else's import } PDefinition renamed = af.createPDefinitionAssistant().findName(node, question.sought, NameScope.TYPENAME); if (renamed != null && node.getDef() instanceof ATypeDefinition) { af.createPDefinitionAssistant().markUsed(node.getDef()); return renamed; } else { return af.createPDefinitionAssistant().findType(node.getDef(), question.sought, question.fromModule); } }
@Override public void caseAImplicitFunctionDefinition( AImplicitFunctionDefinition node, Environment question) throws AnalysisException { if (node.getPrecondition() != null) { node.setPredef(af.createAImplicitFunctionDefinitionAssistant().getPreDefinition(node)); af.createPDefinitionAssistant().markUsed(node.getPredef()); // af.createPDefinitionAssistant().markUsed(node.getPredef()); } else { node.setPredef(null); } if (node.getPostcondition() != null) { node.setPostdef(af.createAImplicitFunctionDefinitionAssistant().getPostDefinition(node)); af.createPDefinitionAssistant().markUsed(node.getPostdef()); } else { node.setPostdef(null); } }
public PDefinition findNameBaseCase(PDefinition d, ILexNameToken sought, NameScope scope) { if (af.getLexNameTokenAssistant().isEqual(d.getName(), sought)) { if (!d.getNameScope().matches(scope)) { TypeChecker.report(3302, "State variable '" + sought.getFullName() + "' cannot be accessed from this context", sought.getLocation()); } markUsed(d); return d; } return null; }
@Override public PType caseANamedTraceDefinition(ANamedTraceDefinition node, TypeCheckInfo question) throws AnalysisException { if (question.env.isVDMPP()) { question = new TypeCheckInfo(question.assistantFactory, new FlatEnvironment(question.assistantFactory, question.assistantFactory.createPDefinitionAssistant().getSelfDefinition(node), question.env), question.scope, question.qualifiers); } for (ATraceDefinitionTerm term : node.getTerms()) { typeCheck(term.getList(), THIS, new TypeCheckInfo(question.assistantFactory, question.env, NameScope.NAMESANDSTATE)); } // Mark node as used, as traces are not used anyway question.assistantFactory.createPDefinitionAssistant().markUsed(node); return null; }
public void updateDefs(AValueDefinition node, TypeCheckInfo question) { PType type = node.getType(); PPattern pattern = node.getPattern(); List<PDefinition> newdefs = af.createPPatternAssistant().getDefinitions(pattern, type, node.getNameScope()); // The untyped definitions may have had "used" markers, so we copy // those into the new typed definitions, lest we get warnings. We // also mark the local definitions as "ValueDefintions" (proxies), // so that classes can be constructed correctly (values are statics). for (PDefinition d : newdefs) { for (PDefinition u : node.getDefs()) { if (u.getName().equals(d.getName())) { if (af.createPDefinitionAssistant().isUsed(u)) { af.createPDefinitionAssistant().markUsed(d); } break; } } ALocalDefinition ld = (ALocalDefinition) d; ld.setValueDefinition(node.clone()); } node.setDefs(newdefs); List<PDefinition> defs = node.getDefs(); af.createPDefinitionListAssistant().setAccessibility(defs, node.getAccess().clone()); af.createPDefinitionListAssistant().setClassDefinition(defs, node.getClassDefinition()); }
PDefinition p = AstFactory.newALocalDefinition(pname.getLocation(), pnameClone, NameScope.NAMES, AstFactory.newAParameterType(pnameClone)); question.assistantFactory.createPDefinitionAssistant().markUsed(p); defs.add(p);
assistantFactory.createPDefinitionAssistant().markUsed(definition);