private List<PDefinition> collectDefs(PDefinition d) { return af.createPDefinitionAssistant().getDefinitions(d); } }
public PDefinition findType(List<PDefinition> definitions, ILexNameToken name, String fromModule) { for (PDefinition d : definitions) { PDefinition def = findType(d, name, fromModule); if (def != null) { return def; } } return null; }
@Override public PType caseAExternalDefinition(AExternalDefinition node) throws AnalysisException { return af.createPDefinitionAssistant().getType(node.getState()); }
@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 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 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); } }
if (question.assistantFactory.createPDefinitionAssistant().isFunction(match)) } else if (!question.assistantFactory.createPDefinitionAssistant().isUpdatable(def)) } else if (encl != null && encl.getAccess().getPure() && question.assistantFactory.createPDefinitionAssistant().isInstanceVariable(def)) node.setType(AstFactory.newAUnknownType(name.getLocation())); return node.getType(); } else if (!question.assistantFactory.createPDefinitionAssistant().isStatic(def) && env.isStatic()) node.setType(question.assistantFactory.createPDefinitionAssistant().getType(def)); return node.getType(); } else node.setType(AstFactory.newAUnknownType(name.getLocation())); return node.getType(); } else if (question.assistantFactory.createPDefinitionAssistant().isFunction(def)) } else if (question.assistantFactory.createPDefinitionAssistant().isOperation(def)) } else if (!question.assistantFactory.createPDefinitionAssistant().isUpdatable(def)) node.setType(question.assistantFactory.createPDefinitionAssistant().getType(def)); return node.getType();
|| question.assistantFactory.createPDefinitionAssistant().hasSupertype(self, question.assistantFactory.createPDefinitionAssistant().getType(classdef))) if (question.assistantFactory.createPDefinitionAssistant().isStatic(fdef) && !question.env.isStatic()) PType type = question.assistantFactory.createPDefinitionAssistant().getType(fdef);
question.assistantFactory.createPDefinitionAssistant().findName(state, sname, NameScope.STATE); // Lookup marks as used && question.assistantFactory.createPDefinitionAssistant().isFunction(encl)) if (question.assistantFactory.createPDefinitionAssistant().isFunctionOrOperation(possible)) if (question.assistantFactory.createPDefinitionAssistant().isStatic(fdef))// && !env.isStatic()) results.add(question.assistantFactory.createPDefinitionAssistant().getType(fdef));
Boolean isStatic = null; List<PDefinition> definitions = question.assistantFactory.createPDefinitionAssistant().getDefinitions(classdef); if (!question.assistantFactory.createPDefinitionAssistant().isCallableOperation(def)) && isStatic != question.assistantFactory.createPDefinitionAssistant().isStatic(def)) isStatic = question.assistantFactory.createPDefinitionAssistant().isStatic(def);
LexNameSet freevars = assistant.getFreeVariables(def, empty); for (ILexNameToken name: assistant.getVariableNames(def)) if (assistant.isTypeDefinition(def) || assistant.isOperation(def))
for (PDefinition f : af.createPDefinitionAssistant().getDefinitions(ct.getClassdef())) PType ftype = af.createPDefinitionAssistant().getType(f);
if (question.assistantFactory.createPDefinitionAssistant().isCallableOperation(def) && !def.getName().getName().equals(classdef.getName().getName())) List<PDefinition> definitions = question.assistantFactory.createPDefinitionAssistant().getDefinitions(classdef); if (!question.assistantFactory.createPDefinitionAssistant().isCallableOperation(def))
if (assistant.isSubclassResponsibility(d)) if (!question.assistantFactory.createPDefinitionAssistant().isCallableOperation(opdef)) PType type = question.assistantFactory.createPDefinitionAssistant().getType(classdef); node.setType(type); return question.assistantFactory.createPTypeAssistant().checkConstraint(question.constraint, type, node.getLocation());
defs.addAll(question.assistantFactory.createPDefinitionAssistant().checkDuplicatePatterns(node, argdefs)); FlatCheckedEnvironment local = new FlatCheckedEnvironment(question.assistantFactory, defs, question.env, question.scope); local.setStatic(question.assistantFactory.createPAccessSpecifierAssistant().isStatic(node.getAccess())); && !question.assistantFactory.createPAccessSpecifierAssistant().isStatic(node.getAccess())) local.add(question.assistantFactory.createPDefinitionAssistant().getSelfDefinition(node)); if (question.assistantFactory.createPTypeAssistant().narrowerThan(question.assistantFactory.createPDefinitionAssistant().getType(node), node.getAccess()))
|| question.getTcFactory().createPDefinitionAssistant().isStatic(rootdef);
if (!af.createPDefinitionAssistant().kind(indef).equals(af.createPDefinitionAssistant().kind(override))) TypeCheckerErrors.detail2("This", af.createPDefinitionAssistant().kind(override), "Super", af.createPDefinitionAssistant().kind(indef)); } else if (af.createPAccessSpecifierAssistant().narrowerThan(override.getAccess(), indef.getAccess())) } else PType to = af.createPDefinitionAssistant().getType(indef); PType from = af.createPDefinitionAssistant().getType(override);
boolean istype = question.assistantFactory.createPDefinitionAssistant().isTypeDefinition(expdef); checkKind(question.assistantFactory, expdef, istype, "type", node); ILexNameToken name = node.getName(); AModuleModules from = node.getFrom(); def.setType((SInvariantType) question.assistantFactory.createPTypeAssistant().typeResolve(question.assistantFactory.createPDefinitionAssistant().getType(def), null, THIS, question)); boolean istype = question.assistantFactory.createPDefinitionAssistant().isTypeDefinition(expdef); checkKind(question.assistantFactory, expdef, istype, "type", node); PType exptype = question.assistantFactory.createPTypeAssistant().typeResolve(expdef.getType(), null, THIS, question);
new PDefinitionAssistantTC(new TypeCheckerAssistantFactory()); assistantFactory.createPDefinitionAssistant().markUsed(definition); assistantFactory.createPDefinitionAssistant().typeResolve(d, tc, new TypeCheckInfo(assistantFactory, env)); } catch (TypeCheckException te)
if (question.assistantFactory.createPDefinitionAssistant().isFunctionOrOperation(possible)) } else PType result = question.assistantFactory.createPDefinitionAssistant().getType(node.getVardef()); node.setType(question.assistantFactory.createPTypeAssistant().typeResolve(question.assistantFactory.createPDefinitionAssistant().getType(node.getVardef()), null, THIS, question));