def readMethodId(self):
packageIndex = self.readVbn()
methodIndex = self.readVbn()
if packageIndex == ids.BUILTIN_PACKAGE_INDEX:
method = builtins.getBuiltinFunctionById(methodIndex)
elif packageIndex == ids.LOCAL_PACKAGE_INDEX:
method = self.package.functions[methodIndex]
else:
method = self.package.dependencies[packageIndex].externFunctions[methodIndex]
return method
def testRewriteClass(self):
package = ir.Package(id=ids.TARGET_PACKAGE_ID)
package.buildNameIndex()
rootType = ir_types.getRootClassType()
trait = package.addTrait(Name(["Tr"]),
typeParameters=[], supertypes=[rootType], flags=frozenset([]))
traitType = ir_types.ClassType(trait)
traitMethod = package.addFunction(Name(["Tr", "m"]),
returnType=ir_types.UnitType, typeParameters=[],
parameterTypes=[traitType],
flags=frozenset([PUBLIC, ABSTRACT,
METHOD]))
trait.methods = [traitMethod]
field = package.newField(Name(["Foo", "x"]),
type=ir_types.I64Type, flags=frozenset([PRIVATE]))
clas = package.addClass(Name(["Foo"]), typeParameters=[],
supertypes=[rootType, traitType],
constructors=[], fields=[field], methods=[],
flags=frozenset([PUBLIC, FINAL, ARRAY]))
typeParam = package.addTypeParameter(clas, Name(["Foo", "T"]),
upperBound=ir_types.getRootClassType(),
lowerBound=ir_types.getNothingClassType(),
flags=frozenset([STATIC]))
clas.elementType = ir_types.VariableType(typeParam)
ty = ir_types.ClassType(clas)
constructor = package.addFunction(Name(["Foo", CONSTRUCTOR_SUFFIX]),
returnType=ir_types.UnitType, typeParameters=[],
parameterTypes=[ty],
flags=frozenset([PUBLIC, METHOD]))
clas.constructors = [constructor]
localMethod = package.addFunction(Name(["Foo", "m"]), returnType=ir_types.I64Type,
typeParameters=[], parameterTypes=[ty],
flags=frozenset([PUBLIC, OVERRIDE,
METHOD]))
otherPackage = ir.Package()
loader = utils_test.FakePackageLoader([otherPackage])
otherMethod = otherPackage.addFunction(Name(["Foo", "o"]),
returnType=ir_types.I64Type,
typeParameters=[],
parameterTypes=[ir_types.getRootClassType()],
flags=frozenset([PUBLIC, METHOD]))
info = CompileInfo(None, package, loader)
externMethod = externalizeDefn(info, otherMethod)
builtinMethod = builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
clas.methods = [localMethod, externMethod, builtinMethod]
self.ser.package = package
self.ser.writeClass(clas)
self.des.package = package
outClass = ir.Class(None, clas.id)
self.des.readClass(outClass)
self.assertEquals(clas, outClass)
def testExternalizeClass(self):
clas = self.otherPackage.addClass(ir.Name(["C"]),
typeParameters=[self.param],
supertypes=[self.rootClassType],
constructors=[], fields=[],
methods=[], elementType=self.varTy,
flags=frozenset([flags.ARRAY, flags.FINAL, flags.PUBLIC]))
clasTy = ir_types.ClassType(clas, (self.varTy,))
ctor = self.otherPackage.addFunction(ir.Name(["C", ir.CONSTRUCTOR_SUFFIX]),
None, ir_types.UnitType, [self.param],
[clasTy], None, None,
frozenset([flags.PUBLIC, flags.METHOD]))
clas.constructors = [ctor]
field = self.otherPackage.newField(ir.Name(["C", "x"]),
type=clasTy, flags=frozenset([flags.PUBLIC]))
clas.fields = [field]
method = self.otherPackage.addFunction(ir.Name(["C", "f"]), None,
ir_types.UnitType, [self.param], [clasTy],
None, None,
frozenset([flags.PUBLIC, flags.METHOD]))
builtinMethod = \
builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
clas.methods = [method, builtinMethod]
externClass = self.externalizer.externalizeDefn(clas)
expected = ir.Class(ir.Name(["C"]), clas.id, typeParameters=[self.externParam],
supertypes=[self.rootClassType],
elementType=self.varTy,
flags=frozenset([flags.ARRAY, flags.FINAL,
flags.PUBLIC, flags.EXTERN]))
expectedCtor = ir.Function(ir.Name(["C", ir.CONSTRUCTOR_SUFFIX]), ctor.id,
returnType=ir_types.UnitType,
typeParameters=[self.externParam],
parameterTypes=[clasTy],
flags=frozenset([flags.PUBLIC, flags.METHOD, flags.EXTERN]))
expected.constructors = [expectedCtor]
expectedField = ir.Field(ir.Name(["C", "x"]), type=clasTy,
flags=frozenset([flags.PUBLIC]))
expected.fields = [expectedField]
expectedMethod = ir.Function(ir.Name(["C", "f"]), method.id,
returnType=ir_types.UnitType,
typeParameters=[self.externParam],
parameterTypes=[clasTy],
flags=frozenset([flags.PUBLIC, flags.METHOD, flags.EXTERN]))
externBuiltinMethod = ir.Function(ir.Name(["Object", "to-string"]), builtinMethod.id,
returnType=ir_types.getStringType(),
typeParameters=[],
parameterTypes=[ir_types.getRootClassType()],
flags=frozenset([flags.EXTERN, flags.PUBLIC, flags.METHOD]))
expected.methods = [expectedMethod, externBuiltinMethod]
self.assertEquals(expected, externClass)
def readMethodId(self, dep=None):
if dep is not None:
methods = dep.externMethods
else:
packageIndex = self.readVbn()
if packageIndex == ids.BUILTIN_PACKAGE_INDEX:
methodIndex = self.readVbn()
return builtins.getBuiltinFunctionById(methodIndex)
elif packageIndex == ids.LOCAL_PACKAGE_INDEX:
methods = self.package.functions
else:
methods = self.package.dependencies[
packageIndex].externFunctions
methodIndex = self.readVbn()
return methods[methodIndex]
def testRewriteClass(self):
package = ir.Package(ids.TARGET_PACKAGE_ID)
typeParam = package.addTypeParameter(ir.Name(["Foo", "T"]),
upperBound=ir_types.getRootClassType(),
lowerBound=ir_types.getNothingClassType(),
flags=frozenset([flags.STATIC]))
supertype = ir_types.getRootClassType()
field = package.newField(ir.Name(["Foo", "x"]),
type=ir_types.I64Type, flags=frozenset([flags.PRIVATE]))
clas = package.addClass(ir.Name(["Foo"]), typeParameters=[typeParam],
supertypes=[supertype],
constructors=[], fields=[field],
methods=[], elementType=ir_types.VariableType(typeParam),
flags=frozenset([flags.PUBLIC, flags.FINAL, flags.ARRAY]))
ty = ir_types.ClassType(clas)
constructor = package.addFunction(ir.Name(["Foo", ir.CONSTRUCTOR_SUFFIX]),
None, ir_types.UnitType, [],
[ty], None, None,
frozenset([flags.PUBLIC, flags.METHOD]))
clas.constructors = [constructor]
localMethod = package.addFunction(ir.Name(["Foo", "m"]), None, ir_types.I64Type, [],
[ty], None, None,
frozenset([flags.PUBLIC, flags.METHOD]))
otherPackage = ir.Package()
loader = utils_test.FakePackageLoader([otherPackage])
otherMethod = otherPackage.addFunction(ir.Name(["Foo", "o"]), None, ir_types.I64Type,
[], [ir_types.getRootClassType()], None, None,
frozenset([flags.PUBLIC, flags.METHOD]))
externalizer = externalization.Externalizer(package, loader)
externMethod = externalizer.externalizeDefn(otherMethod)
builtinMethod = builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
clas.methods = [localMethod, externMethod, builtinMethod]
self.ser.package = package
self.ser.writeClass(clas)
self.des.package = package
outClass = ir.Class(None, clas.id)
self.des.readClass(outClass)
self.assertEquals(clas, outClass)
def testExternalizeBuiltinMethodName(self):
method = builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_EQ_OP_ID)
externMethod = externalizeMethod(self.info, method, self.dep)
self.assertIn(method.name.short(), self.package.strings)
def testExternalizeClass(self):
clas = self.otherPackage.addClass(Name(["C"]),
typeParameters=[],
supertypes=[self.rootClassType],
constructors=[], fields=[],
methods=[], elementType=None,
flags=frozenset([ARRAY, FINAL, PUBLIC]))
T = self.otherPackage.addTypeParameter(clas, Name(["C", "T"]),
upperBound=ir_types.getRootClassType(),
lowerBound=ir_types.getNothingClassType(),
flags=frozenset([STATIC]))
TTy = ir_types.VariableType(T)
clas.elementType = TTy
clasTy = ir_types.ClassType.forReceiver(clas)
ctor = self.otherPackage.addFunction(Name(["C", CONSTRUCTOR_SUFFIX]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PUBLIC, METHOD, CONSTRUCTOR]))
privateCtor = self.otherPackage.addFunction(Name(["C", CONSTRUCTOR_SUFFIX]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PRIVATE, METHOD, CONSTRUCTOR]))
clas.constructors = [ctor, privateCtor]
field = self.otherPackage.newField(Name(["C", "x"]),
type=clasTy, flags=frozenset([PUBLIC]))
privateField = self.otherPackage.newField(Name(["C", "y"]),
type=clasTy, flags=frozenset([PRIVATE]))
clas.fields = [field, privateField]
method = self.otherPackage.addFunction(Name(["C", "f"]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PUBLIC, METHOD]))
privateMethod = self.otherPackage.addFunction(Name(["C", "g"]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PRIVATE, METHOD]))
builtinMethod = \
builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
clas.methods = [method, privateMethod, builtinMethod]
externClass = externalizeDefn(self.info, clas)
expected = ir.Class(Name(["C"]), clas.id, typeParameters=[T],
supertypes=[self.rootClassType],
elementType=TTy,
flags=frozenset([ARRAY, FINAL,
PUBLIC, EXTERN]))
expectedCtor = ir.Function(Name(["C", CONSTRUCTOR_SUFFIX]), ctor.id,
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PUBLIC, METHOD, CONSTRUCTOR, EXTERN]))
expected.constructors = [expectedCtor]
expectedField = ir.Field(Name(["C", "x"]), type=clasTy,
flags=frozenset([PUBLIC]))
expected.fields = [expectedField]
expectedMethod = ir.Function(Name(["C", "f"]), method.id,
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PUBLIC, METHOD, EXTERN]))
externBuiltinMethod = ir.Function(Name(["Object", "to-string"]), builtinMethod.id,
returnType=ir_types.getStringType(),
typeParameters=[],
parameterTypes=[ir_types.getRootClassType()],
flags=frozenset([EXTERN, PUBLIC, METHOD]))
expected.methods = [expectedMethod, externBuiltinMethod]
self.assertEquals(expected, externClass)
def testExternalizeBuiltinMethodName(self):
method = builtins.getBuiltinFunctionById(
bytecode.BUILTIN_ROOT_CLASS_EQ_OP_ID)
externMethod = externalizeMethod(self.info, method, self.dep)
self.assertIn(method.name.short(), self.package.strings)
def testExternalizeClass(self):
clas = self.otherPackage.addClass(Name(["C"]),
typeParameters=[],
supertypes=[self.rootClassType],
constructors=[],
fields=[],
methods=[],
elementType=None,
flags=frozenset(
[ARRAY, FINAL, PUBLIC]))
T = self.otherPackage.addTypeParameter(
clas,
Name(["C", "T"]),
upperBound=ir_types.getRootClassType(),
lowerBound=ir_types.getNothingClassType(),
flags=frozenset([STATIC]))
TTy = ir_types.VariableType(T)
clas.elementType = TTy
clasTy = ir_types.ClassType.forReceiver(clas)
ctor = self.otherPackage.addFunction(
Name(["C", CONSTRUCTOR_SUFFIX]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PUBLIC, METHOD, CONSTRUCTOR]))
privateCtor = self.otherPackage.addFunction(
Name(["C", CONSTRUCTOR_SUFFIX]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PRIVATE, METHOD, CONSTRUCTOR]))
clas.constructors = [ctor, privateCtor]
field = self.otherPackage.newField(Name(["C", "x"]),
type=clasTy,
flags=frozenset([PUBLIC]))
privateField = self.otherPackage.newField(Name(["C", "y"]),
type=clasTy,
flags=frozenset([PRIVATE]))
clas.fields = [field, privateField]
method = self.otherPackage.addFunction(Name(["C", "f"]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset(
[PUBLIC, METHOD]))
privateMethod = self.otherPackage.addFunction(
Name(["C", "g"]),
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PRIVATE, METHOD]))
builtinMethod = \
builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
clas.methods = [method, privateMethod, builtinMethod]
externClass = externalizeDefn(self.info, clas)
expected = ir.Class(Name(["C"]),
clas.id,
typeParameters=[T],
supertypes=[self.rootClassType],
elementType=TTy,
flags=frozenset([ARRAY, FINAL, PUBLIC, EXTERN]))
expectedCtor = ir.Function(Name(["C", CONSTRUCTOR_SUFFIX]),
ctor.id,
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset(
[PUBLIC, METHOD, CONSTRUCTOR, EXTERN]))
expected.constructors = [expectedCtor]
expectedField = ir.Field(Name(["C", "x"]),
type=clasTy,
flags=frozenset([PUBLIC]))
expected.fields = [expectedField]
expectedMethod = ir.Function(Name(["C", "f"]),
method.id,
returnType=ir_types.UnitType,
typeParameters=[T],
parameterTypes=[clasTy],
flags=frozenset([PUBLIC, METHOD, EXTERN]))
externBuiltinMethod = ir.Function(
Name(["Object", "to-string"]),
builtinMethod.id,
returnType=ir_types.getStringType(),
typeParameters=[],
parameterTypes=[ir_types.getRootClassType()],
flags=frozenset([EXTERN, PUBLIC, METHOD]))
expected.methods = [expectedMethod, externBuiltinMethod]
self.assertEquals(expected, externClass)
def testRewriteBuiltinFunctionId(self):
function = builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
self.ser.writeMethodId(function)
outFunction = self.des.readMethodId()
self.assertIs(function, outFunction)
def testRewriteBuiltinFunctionId(self):
function = builtins.getBuiltinFunctionById(bytecode.BUILTIN_ROOT_CLASS_TO_STRING_ID)
self.ser.writeMethodId(function)
outFunction = self.des.readMethodId()
self.assertIs(function, outFunction)
