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())
