def testAnonymousAnyType(self): # any x argument = CategoryParameter(AnyType.instance, "x") argument.register(self.context) st = argument.getType(self.context) self.assertIsInstance(st, AnyType) self.assertTrue(st.isAssignableFrom(self.context, BooleanType.instance)) self.assertTrue(st.isAssignableFrom(self.context, IntegerType.instance)) self.assertTrue(st.isAssignableFrom(self.context, DecimalType.instance)) self.assertTrue(st.isAssignableFrom(self.context, TextType.instance)) self.assertTrue(st.isAssignableFrom(self.context, DateType.instance)) self.assertTrue( st.isAssignableFrom(self.context, DateTimeType.instance)) self.assertTrue(st.isAssignableFrom( self.context, MissingType.instance)) # missing type always compatible self.assertTrue(st.isAssignableFrom(self.context, AnyType.instance)) self.assertTrue( st.isAssignableFrom(self.context, CategoryType("Simple"))) self.assertTrue(st.isAssignableFrom(self.context, CategoryType("Root"))) self.assertTrue( st.isAssignableFrom(self.context, CategoryType("DerivedWithOther"))) self.assertTrue( st.isAssignableFrom(self.context, CategoryType("DerivedWithName")))
def testAnonymousCategoryType(self): # Root x argument = CategoryParameter(CategoryType("Root"), "x") argument.register(self.context) st = argument.getType(self.context) self.assertIsInstance(st, CategoryType) self.assertFalse( st.isAssignableFrom(self.context, BooleanType.instance)) self.assertFalse( st.isAssignableFrom(self.context, IntegerType.instance)) self.assertFalse( st.isAssignableFrom(self.context, DecimalType.instance)) self.assertFalse(st.isAssignableFrom(self.context, TextType.instance)) self.assertFalse(st.isAssignableFrom(self.context, DateType.instance)) self.assertFalse( st.isAssignableFrom(self.context, DateTimeType.instance)) self.assertFalse( st.isAssignableFrom(self.context, MissingType.instance)) self.assertFalse(st.isAssignableFrom( self.context, AnyType.instance)) # any type never compatible self.assertFalse( st.isAssignableFrom( self.context, CategoryType("Simple"))) # since Simple does not extend Root self.assertTrue(st.isAssignableFrom( self.context, CategoryType("Root"))) # since Root is Root self.assertTrue( st.isAssignableFrom(self.context, CategoryType( "DerivedWithOther"))) # since DerivedWithOther extends Root self.assertTrue( st.isAssignableFrom(self.context, CategoryType( "DerivedWithName"))) # since DerivedWithName extends Root
def testAnonymousAnyTypeWithAttribute(self): # any x with attribute: name list = IdentifierList("name") argument = ExtendedParameter(AnyType.instance, "x", list) argument.register(self.context) st = argument.getType(self.context) self.assertIsInstance(st, CategoryType) self.assertFalse( st.isAssignableFrom(self.context, BooleanType.instance)) self.assertFalse( st.isAssignableFrom(self.context, IntegerType.instance)) self.assertFalse( st.isAssignableFrom(self.context, DecimalType.instance)) self.assertFalse(st.isAssignableFrom(self.context, TextType.instance)) self.assertFalse(st.isAssignableFrom(self.context, DateType.instance)) self.assertFalse( st.isAssignableFrom(self.context, DateTimeType.instance)) self.assertFalse( st.isAssignableFrom(self.context, MissingType.instance)) self.assertFalse(st.isAssignableFrom( self.context, AnyType.instance)) # any type never compatible self.assertTrue( st.isAssignableFrom( self.context, CategoryType("Simple"))) # since Simple has a name self.assertFalse( st.isAssignableFrom( self.context, CategoryType("Root"))) # since Root has no name self.assertFalse( st.isAssignableFrom(self.context, CategoryType( "DerivedWithOther"))) # since DerivedWithOther has no name self.assertTrue( st.isAssignableFrom(self.context, CategoryType( "DerivedWithName"))) # since DerivedWithName has a name
def readItemType(self, stored): # val = getattr(stored, "category") # category = val[-1] category = stored.categories[-1] typ = CategoryType(category) typ.mutable = self.mutable return typ
def interpret (self, context): store = DataStore.instance query = self.buildFetchOneQuery(context, store) stored = store.fetchOne (query) if stored is None: return NullValue.instance else: typeName = stored.getData("category")[-1] typ = CategoryType(typeName) if self.typ is not None: typ.mutable = self.typ.mutable return typ.newInstanceFromStored (context, stored)
def testDateType(self): st = DateType.instance self.assertEqual(st, DateType.instance) self.assertFalse(isAssignableTo(self.context, st, BooleanType.instance)) self.assertFalse(isAssignableTo(self.context, st, IntegerType.instance)) self.assertFalse(isAssignableTo(self.context, st, DecimalType.instance)) self.assertFalse(isAssignableTo(self.context, st, TextType.instance)) self.assertTrue(isAssignableTo(self.context, st, DateType.instance)) self.assertFalse(isAssignableTo(self.context, st, DateTimeType.instance)) self.assertTrue(isAssignableTo(self.context, st, MissingType.instance)) self.assertTrue(isAssignableTo(self.context, st, AnyType.instance)) self.assertFalse(isAssignableTo(self.context, st, CategoryType("Root"))) self.assertFalse(isAssignableTo(self.context, st, CategoryType("Derived"))) self.assertFalse(isAssignableTo(self.context, st, CategoryType("Unrelated")))
def resolveConstructor(self, context): from prompto.type.CategoryType import CategoryType try: ctor = ConstructorExpression(CategoryType(self.name), None, None) ctor.check(context) return ctor except SyntaxError as e: return None
def resolveUnresolvedDeclaration(self, context, name): decl = context.getRegisteredDeclaration(IDeclaration, name) if decl is None: raise SyntaxError("Unknown name:" + name) if isinstance(decl, CategoryDeclaration): return ConstructorExpression(CategoryType(name), None, self.arguments) else: return MethodCall(MethodSelector(name), self.arguments)
def check(self, context): from prompto.declaration.AttributeDeclaration import AttributeDeclaration if self.attributes is not None: for attribute in self.attributes: ad = context.getRegisteredDeclaration(AttributeDeclaration, attribute) if ad is None and attribute != "text": raise SyntaxError("Unknown attribute: \"" + attribute + "\"") return CategoryType(self.getName())
def __init__(self, context, declaration): from prompto.type.CategoryType import CategoryType super(ConcreteInstance, self).__init__(CategoryType(declaration.name)) self.declaration = declaration self.storable = None if declaration.storable: categories = declaration.collectCategories(context) self.storable = DataStore.instance.newStorable(categories) self.mutable = False self.values = dict()
def __init__(self, context, declaration): from prompto.type.CategoryType import CategoryType super(ConcreteInstance, self).__init__(CategoryType(declaration.name)) self.declaration = declaration self.storable = None if declaration.storable: categories = declaration.collectCategories(context) factory = { "provider": lambda: self.getDbId(), "listener": lambda dbId: self.setDbId(dbId), "isUpdate": True } self.storable = DataStore.instance.newStorableDocument(categories, factory) self.mutable = False self.values = dict()
def inferCommonCategoryType(self, context, type1, type2, trySwap): from prompto.declaration.CategoryDeclaration import CategoryDeclaration from prompto.type.CategoryType import CategoryType decl1 = context.getRegisteredDeclaration(CategoryDeclaration, type1.typeName) if decl1.derivedFrom is not None: for name in decl1.derivedFrom: parentType = CategoryType(name) if parentType.isAssignableFrom(context, type2): return parentType # climb up the tree for name in decl1.derivedFrom: parentType = CategoryType(name) commonType = self.inferCommonBaseType(context, parentType, type2) if commonType is not None: return commonType if trySwap: return self.inferCommonCategoryType(context, type2, type1, False) else: return None
def populateError(self, e, context): error = e.getExpression(context) if error == None: exp = ConstructorExpression(CategoryType("Error"), None, None) args = ArgumentList() args.append(Argument(UnresolvedParameter("name"), TextLiteral(type(e).__name__))) args.append(Argument(UnresolvedParameter("text"), TextLiteral(e.getMessage()))) exp.setArguments(args) error = exp if context.getRegisteredValue(INamedInstance, self.errorName) == None: context.registerValue(ErrorVariable(self.errorName)) if isinstance(error, IExpression): error = error.interpret(context) context.setValue(self.errorName, error) return error
def resolveType(self, context): from prompto.declaration.EnumeratedCategoryDeclaration import EnumeratedCategoryDeclaration from prompto.declaration.CategoryDeclaration import CategoryDeclaration from prompto.type.EnumeratedCategoryType import EnumeratedCategoryType from prompto.type.CategoryType import CategoryType decl = context.getRegisteredDeclaration(IDeclaration, self.name) if isinstance(decl, EnumeratedCategoryDeclaration): return TypeExpression(EnumeratedCategoryType(self.name)) elif isinstance(decl, CategoryDeclaration): return TypeExpression(CategoryType(self.name)) elif isinstance(decl, EnumeratedNativeDeclaration): return TypeExpression(decl.getType(context)) else: for type in NativeType.getAll(): if self.name == type.getName(): return TypeExpression(type) return None
def interpret(self, context, errorName): exp = self.getExpression(context) if exp is None: from prompto.grammar.Argument import Argument from prompto.grammar.ArgumentList import ArgumentList from prompto.expression.ConstructorExpression import ConstructorExpression from prompto.param.UnresolvedParameter import UnresolvedParameter from prompto.literal.TextLiteral import TextLiteral from prompto.type.CategoryType import CategoryType args = ArgumentList() args.append( Argument(UnresolvedParameter("name"), TextLiteral(type(self).__name__))) args.append( Argument(UnresolvedParameter("text"), TextLiteral(self.message))) exp = ConstructorExpression(CategoryType("Error"), args, None) if context.getRegisteredValue(object, errorName) is None: from prompto.runtime.ErrorVariable import ErrorVariable context.registerValue(ErrorVariable(errorName)) error = exp.interpret(context) context.setValue(errorName, error) return error
def toMutable(self): from prompto.type.CategoryType import CategoryType result = copy.copy(self) result.itype = CategoryType(self.itype.typeName, True) result.mutable = True return result
def getType(self, context): from prompto.type.CategoryType import CategoryType return CategoryType(self.getName())
def check(self, context): sourceType = self.source.check(context) if not isinstance(sourceType, CategoryType): raise SyntaxError("Expected a category instance, found:" + str(sourceType)) return CategoryType(sourceType.typeName, mutable=True)
def check(self, context): itype = self.expression.check(context) if not CategoryType("Error").isAssignableFrom(context, itype): raise SyntaxError(itype.getName() + " does not extend Error") return VoidType.instance
def getType(self, context): return CategoryType(self.getName())