public TypeCheckInfo newConstraint(PType newConstraint) { TypeCheckInfo info = new TypeCheckInfo(assistantFactory, env, scope, qualifiers, newConstraint, returnType); return info; }
public TypeCheckInfo newInfo(Environment newEnv) { TypeCheckInfo info = new TypeCheckInfo(assistantFactory, newEnv, scope, qualifiers, constraint, returnType); return info; }
public TypeCheckInfo newInfo(Environment newEnv, NameScope newScope) { TypeCheckInfo info = new TypeCheckInfo(assistantFactory, newEnv, newScope, qualifiers, constraint, returnType); return info; }
public TypeCheckInfo newScope(NameScope newScope) { TypeCheckInfo info = new TypeCheckInfo(assistantFactory, env, newScope, qualifiers, constraint, returnType); return info; }
public TypeCheckInfo newScope(List<PDefinition> definitions, NameScope newScope) { Environment newEnv = new FlatCheckedEnvironment(assistantFactory, definitions, env, newScope); TypeCheckInfo info = new TypeCheckInfo(assistantFactory, newEnv, newScope); return info; } }
@Override public PType caseANewObjectDesignator(ANewObjectDesignator node, TypeCheckInfo question) throws AnalysisException { return node.getExpression().apply(THIS, new TypeCheckInfo(question.assistantFactory, question.env, NameScope.NAMESANDSTATE, question.qualifiers)); }
@Override public PType caseAIdentifierObjectDesignator( AIdentifierObjectDesignator node, TypeCheckInfo question) throws AnalysisException { return node.getExpression().apply(THIS, new TypeCheckInfo(question.assistantFactory, question.env, NameScope.NAMESANDSTATE, question.qualifiers)); }
public void typeCheck(PPattern pattern, TypeCheckInfo question, IQuestionAnswer<TypeCheckInfo, PType> typeCheckVisitor) { try { pattern.apply(new TypeCheckerPatternVisitor(typeCheckVisitor), new TypeCheckInfo(question.assistantFactory, question.env, question.scope)); } catch (AnalysisException e) { } }
public void typeCheck(List<PExport> exports, ModuleEnvironment env) throws AnalysisException { TypeCheckVisitor tc = new TypeCheckVisitor(); TypeCheckInfo question = new TypeCheckInfo(af, env, null, null); for (PExport exp : exports) { exp.apply(tc, question); } } }
@Override public void typeCheck() { try { type = expression.apply(new TypeCheckVisitor(), new TypeCheckInfo(assistantFactory, env, NameScope.NAMESANDSTATE)); } catch (AnalysisException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public void typeCheck(AFromModuleImports ifm, ModuleEnvironment env) throws AnalysisException { TypeCheckVisitor tc = new TypeCheckVisitor(); TypeCheckInfo question = new TypeCheckInfo(af, env, null, null); for (List<PImport> ofType : ifm.getSignatures()) { for (PImport imp : ofType) { imp.apply(tc, question); } } }
@Override public void defaultSClassDefinition(SClassDefinition node, NewQuestion question) throws AnalysisException { Environment cenv = new FlatEnvironment(question.question.assistantFactory, node.getDefinitions(), question.question.env); af.createPDefinitionListAssistant().typeResolve(node.getDefinitions(), question.rootVisitor, new TypeCheckInfo(question.question.assistantFactory, cenv)); }
public void typeResolve(SClassDefinition d, QuestionAnswerAdaptor<TypeCheckInfo, PType> rootVisitor, TypeCheckInfo question) throws AnalysisException { Environment cenv = new FlatEnvironment(question.assistantFactory, d.getDefinitions(), question.env); af.createPDefinitionListAssistant().typeResolve(d.getDefinitions(), rootVisitor, new TypeCheckInfo(question.assistantFactory, cenv)); }
@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 PType seqApply(AApplyObjectDesignator node, SSeqType seq, Environment env, NameScope scope, boolean unique, IQuestionAnswer<TypeCheckInfo, PType> rootVisitor, TypeCheckInfo question) throws AnalysisException { if (node.getArgs().size() != 1) { TypeCheckerErrors.concern(unique, 3252, "Sequence application must have one argument", node.getLocation(), node); return AstFactory.newAUnknownType(node.getLocation()); } PType argtype = node.getArgs().get(0).apply(rootVisitor, new TypeCheckInfo(question.assistantFactory, env, scope)); if (!env.af.createPTypeAssistant().isNumeric(argtype)) { TypeCheckerErrors.concern(unique, 3253, "Sequence argument is not numeric", node.getLocation(), node); TypeCheckerErrors.detail(unique, "Type", argtype); } return seq.getSeqof(); }
public PType mapApply(AApplyObjectDesignator node, SMapType map, Environment env, NameScope scope, boolean unique, IQuestionAnswer<TypeCheckInfo, PType> rootVisitor) throws AnalysisException { if (node.getArgs().size() != 1) { TypeCheckerErrors.concern(unique, 3250, "Map application must have one argument", node.getLocation(), node); return AstFactory.newAUnknownType(node.getLocation()); } PType argtype = node.getArgs().get(0).apply(rootVisitor, new TypeCheckInfo(env.af, env, scope)); if (!env.af.getTypeComparator().compatible(map.getFrom(), argtype)) { TypeCheckerErrors.concern(unique, 3251, "Map application argument is incompatible type", node.getLocation(), node); TypeCheckerErrors.detail2(unique, "Map domain", map.getFrom(), "Argument", argtype); } return map.getTo(); }
@Override public PType caseAThreadDefinition(AThreadDefinition node, TypeCheckInfo question) throws AnalysisException { question.scope = NameScope.NAMESANDSTATE; FlatEnvironment local = new FlatEnvironment(question.assistantFactory, question.assistantFactory.createPDefinitionAssistant().getSelfDefinition(node), question.env); PType rt = node.getStatement().apply(THIS, new TypeCheckInfo(question.assistantFactory, local, question.scope)); if (!(rt instanceof AVoidType) && !(rt instanceof AUnknownType)) { TypeCheckerErrors.report(3049, "Thread statement/operation must not return a value", node.getLocation(), node); } node.setType(rt); node.getOperationDef().setBody(node.getStatement().clone());// This // operation // is a // wrapper // for the // thread return rt; }
@Override public PType caseAMapCompMapExp(AMapCompMapExp node, TypeCheckInfo question) throws AnalysisException { PDefinition def = AstFactory.newAMultiBindListDefinition(node.getLocation(), node.getBindings()); def.apply(THIS, question.newConstraint(null)); Environment local = new FlatCheckedEnvironment(question.assistantFactory, def, question.env, question.scope); PExp predicate = node.getPredicate(); TypeCheckInfo pquestion = new TypeCheckInfo(question.assistantFactory, local, question.scope, null, AstFactory.newABooleanBasicType(node.getLocation()), null); if (predicate != null && !question.assistantFactory.createPTypeAssistant().isType(predicate.apply(THIS, pquestion), ABooleanBasicType.class)) { TypeCheckerErrors.report(3118, "Predicate is not boolean", predicate.getLocation(), predicate); } node.setType(node.getFirst().apply(THIS, question.newInfo(local))); local.unusedCheck(); return node.getType(); }
@Override public PType caseAForAllExp(AForAllExp node, TypeCheckInfo question) throws AnalysisException { PDefinition def = AstFactory.newAMultiBindListDefinition(node.getLocation(), node.getBindList()); def.apply(THIS, question.newConstraint(null)); Environment local = new FlatCheckedEnvironment(question.assistantFactory, def, question.env, question.scope); if (!question.assistantFactory.createPTypeAssistant().isType(node.getPredicate().apply(THIS, new TypeCheckInfo(question.assistantFactory, local, question.scope, null, AstFactory.newABooleanBasicType(node.getLocation()), null)), ABooleanBasicType.class)) { TypeCheckerErrors.report(3097, "Predicate is not boolean", node.getPredicate().getLocation(), node.getPredicate()); } local.unusedCheck(); node.setType(AstFactory.newABooleanBasicType(node.getLocation())); return question.assistantFactory.createPTypeAssistant().checkConstraint(question.constraint, node.getType(), node.getLocation()); }
@Override public PType caseAExistsExp(AExistsExp node, TypeCheckInfo question) throws AnalysisException { PDefinition def = AstFactory.newAMultiBindListDefinition(node.getLocation(), node.getBindList()); def.apply(THIS, question.newConstraint(null)); def.setNameScope(NameScope.LOCAL); Environment local = new FlatCheckedEnvironment(question.assistantFactory, def, question.env, question.scope); question = new TypeCheckInfo(question.assistantFactory, local, question.scope, null, AstFactory.newABooleanBasicType(node.getLocation()), null); if (!question.assistantFactory.createPTypeAssistant().isType(node.getPredicate().apply(THIS, question), ABooleanBasicType.class)) { TypeCheckerErrors.report(3089, "Predicate is not boolean", node.getPredicate().getLocation(), node.getPredicate()); } local.unusedCheck(); node.setType(AstFactory.newABooleanBasicType(node.getLocation())); return question.assistantFactory.createPTypeAssistant().checkConstraint(question.constraint, node.getType(), node.getLocation()); }