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)