Fix whitespace in clrtype.py

Author: slozier

Src/IronPython/Lib/clrtype.py

@@ -34,7 +34,7 @@ def validate_clr_types(signature_types, var_signature = False):
         if type(t) is type(System.IComparable): # type overloaded on generic arity, eg IComparable and IComparable[T]
             t = t[()] # select non-generic version
         clr_type = clr.GetClrType(t)
-        if t == Void: 
+        if t == Void:
             raise TypeError("Void cannot be used in signature")
         is_typed = clr.GetPythonType(clr_type) == t
         # is_typed needs to be weakened until the generated type
@@ -53,7 +53,7 @@ class TypedFunction(object):
     """
     A strongly-typed function can get wrapped up as a staticmethod, a property, etc.
     This class represents the raw function, but with the type information
-    it is decorated with. 
+    it is decorated with.
     Other information is stored as attributes on the function. See propagate_attributes
     """
     def __init__(self, function, is_static = False, prop_name_if_prop_get = None, prop_name_if_prop_set = None):
@@ -90,7 +90,7 @@ def emit_properties(self, typebld):
         for prop, prop_name, clr_prop_type in self.get_typed_properties():
             self.emit_property(typebld, prop, prop_name, clr_prop_type)
 
-    def emit_property(self, typebld, prop, name, clrtype):	
+    def emit_property(self, typebld, prop, name, clrtype):
         prpbld = typebld.DefineProperty(name, PropertyAttributes_None, clrtype, None)
         if prop.fget:
             getter = self.emitted_methods[(prop.fget.__name__, prop.fget.arg_types)]
@@ -100,13 +100,13 @@ def emit_property(self, typebld, prop, name, clrtype):
             prpbld.SetSetMethod(setter)
 
     def dummy_function(self): raise RuntimeError("this should not get called")
-    
+
     def get_typed_methods(self):
         """
         Get all the methods with @accepts (and @returns) decorators
         Functions are assumed to be instance methods, unless decorated with @staticmethod
         """
-        
+
         # We avoid using the "types" library as it is not a builtin
         FunctionType = type(ClrType.__dict__["dummy_function"])
 
@@ -134,9 +134,9 @@ def get_typed_methods(self):
 
     def emit_methods(self, typebld):
         # We need to track the generated methods so that we can emit properties
-        # referring these methods. 
-        # Also, the hash is indexed by name *and signature*. Even though Python does 
-        # not have method overloading, property getter and setter functions can have 
+        # referring these methods.
+        # Also, the hash is indexed by name *and signature*. Even though Python does
+        # not have method overloading, property getter and setter functions can have
         # the same __name__ attribute
         self.emitted_methods = {}
         for function_info in self.get_typed_methods():
@@ -166,19 +166,19 @@ def get_clr_type_name(self):
             return self.__name__
 
     def create_type(self, typebld):
-        self.emit_members(typebld)	
-        new_type = typebld.CreateType()        
-        self.map_members(new_type)        
+        self.emit_members(typebld)
+        new_type = typebld.CreateType()
+        self.map_members(new_type)
         return new_type
 
 class ClrInterface(ClrType):
     """
     Set __metaclass__ in a Python class declaration to declare a
-    CLR interface type. 
+    CLR interface type.
     You need to specify object as the base-type if you do not specify any other
     interfaces as the base interfaces
     """
-    
+
     def __init__(self, *args):
         return super(ClrInterface, self).__init__(*args)
 
@@ -191,7 +191,7 @@ def emit_method(self, typebld, function_info):
             attributes,
             function.return_type,
             function.arg_types)
-        
+
         instance_offset = 0 if function_info.is_static else 1
         arg_names = function.__code__.co_varnames
         for i in range(len(function.arg_types)):
@@ -201,16 +201,16 @@ def emit_method(self, typebld, function_info):
         if hasattr(function, "CustomAttributeBuilders"):
             for cab in function.CustomAttributeBuilders:
                 method_builder.SetCustomAttribute(cab)
-        
+
         return method_builder
-	            
+
     def emit_members(self, typebld):
         self.emit_methods(typebld)
         self.emit_properties(typebld)
         self.emit_classattribs(typebld)
 
     def map_members(self, new_type): pass
-    
+
     interface_module_builder = None
 
     @staticmethod
@@ -228,7 +228,7 @@ def define_interface(typename, bases):
     def map_clr_type(self, clr_type):
         """
         TODO - Currently "t = clr.GetPythonType(clr.GetClrType(C)); t == C" will be False
-        for C where C.__metaclass__ is ClrInterface, even though both t and C 
+        for C where C.__metaclass__ is ClrInterface, even though both t and C
         represent the same CLR type. This can be fixed by publishing a mapping
         between t and C in the IronPython runtime.
         """
@@ -269,10 +269,10 @@ class ClrClass(ClrInterface):
     """
     Set __metaclass__ in a Python class declaration to specify strong-type
     information for the class or its attributes. The Python class
-    retains its Python attributes, like being able to add or remove methods.    
+    retains its Python attributes, like being able to add or remove methods.
     """
 
-    # Holds the FieldInfo for a static CLR field which points to a 
+    # Holds the FieldInfo for a static CLR field which points to a
     # Microsoft.Scripting.Runtime.DynamicOperations corresponding to the current ScriptEngine
     dynamic_operations_field = None
 
@@ -282,27 +282,27 @@ def emit_fields(self, typebld):
                 field_type = self._clrfields[fldname]
                 validate_clr_types(field_type)
                 typebld.DefineField(
-                    fldname, 
-                    clr.GetClrType(field_type), 
+                    fldname,
+                    clr.GetClrType(field_type),
                     FieldAttributes.Public)
 
     def map_fields(self, new_type):
         if hasattr(self, "_clrfields"):
-            for fldname in self._clrfields: 
+            for fldname in self._clrfields:
                 fldinfo = new_type.GetField(fldname)
                 setattr(self, fldname, ReflectedField(fldinfo))
-            
+
     @staticmethod
     def get_dynamic_operations_field():
-        if ClrClass.dynamic_operations_field: 
+        if ClrClass.dynamic_operations_field:
             return ClrClass.dynamic_operations_field
         python_context = clr.GetCurrentRuntime().GetLanguage(PythonContext)
         dynamic_operations = DynamicOperations(python_context)
-        
+
         typegen = Snippets.Shared.DefineType(
-            "DynamicOperationsHolder" + str(hash(python_context)), 
-            object, 
-            True, 
+            "DynamicOperationsHolder" + str(hash(python_context)),
+            object,
+            True,
             False)
         typebld = typegen.TypeBuilder
         typebld.DefineField(
@@ -311,22 +311,22 @@ def get_dynamic_operations_field():
             FieldAttributes.Public | FieldAttributes.Static)
         new_type = typebld.CreateType()
         ClrClass.dynamic_operations_field = new_type.GetField("DynamicOperations")
-        
+
         ClrClass.dynamic_operations_field.SetValue(None, dynamic_operations)
-        
+
         return ClrClass.dynamic_operations_field
-        
+
     def emit_typed_stub_to_python_method(self, typebld, function_info):
         function = function_info.function
         """
-        Generate a stub method that repushes all the arguments and 
+        Generate a stub method that repushes all the arguments and
         dispatches to DynamicOperations.InvokeMember
         """
         invoke_member = clr.GetClrType(DynamicOperations).GetMethod(
-            "InvokeMember", 
+            "InvokeMember",
             Array[Type]((object, str, Array[object])))
 
-        # Type.GetMethod raises an AmbiguousMatchException if there is a generic and a non-generic method 
+        # Type.GetMethod raises an AmbiguousMatchException if there is a generic and a non-generic method
         # (like DynamicOperations.GetMember) with the same name and signature. So we have to do things
         # the hard way
         get_member_search = [m for m in clr.GetClrType(DynamicOperations).GetMethods() if m.Name == "GetMember" and not m.IsGenericMethod and m.GetParameters().Length == 2]
@@ -365,12 +365,12 @@ def emit_typed_stub_to_python_method(self, typebld, function_info):
             p = method_builder.DefineParameter(i + 1, ParameterAttributes_None, arg_names[i + instance_offset])
 
         ilgen = method_builder.GetILGenerator()
-        
+
         args_array = ilgen.DeclareLocal(Array[object])
         args_count = len(function.arg_types)
         ilgen.Emit(OpCodes.Ldc_I4, args_count)
         ilgen.Emit(OpCodes.Newarr, object)
-        ilgen.Emit(OpCodes.Stloc, args_array)            
+        ilgen.Emit(OpCodes.Stloc, args_array)
         for i in range(args_count):
             arg_type = function.arg_types[i]
             if clr.GetClrType(arg_type).IsByRef:
@@ -380,7 +380,7 @@ def emit_typed_stub_to_python_method(self, typebld, function_info):
             ilgen.Emit(OpCodes.Ldarg, i + int(not function_info.is_static))
             ilgen.Emit(OpCodes.Box, arg_type)
             ilgen.Emit(OpCodes.Stelem_Ref)
-        
+
         has_return_value = True
         if function_info.prop_name_if_prop_get:
             ilgen.Emit(OpCodes.Ldsfld, ClrClass.get_dynamic_operations_field())
@@ -401,7 +401,7 @@ def emit_typed_stub_to_python_method(self, typebld, function_info):
                 # ilgen.Emit(OpCodes.Ldsfld, class_object)
             else:
                 ilgen.Emit(OpCodes.Ldarg, 0)
-            
+
             ilgen.Emit(OpCodes.Ldstr, function.__name__)
             ilgen.Emit(OpCodes.Ldloc, args_array)
             ilgen.Emit(OpCodes.Callvirt, invoke_member)
@@ -460,7 +460,7 @@ def emit_method(self, typebld, function_info):
                 method_builder.SetCustomAttribute(cab)
 
         return method_builder
-	            
+
     def map_pinvoke_methods(self, new_type):
         pythonType = clr.GetPythonType(new_type)
         for function_info in self.get_typed_methods():
@@ -469,20 +469,20 @@ def map_pinvoke_methods(self, new_type):
                 # Overwrite the Python function with the pinvoke_method
                 pinvoke_method = getattr(pythonType, function.__name__)
                 setattr(self, function.__name__, pinvoke_method)
-	  
+
     def emit_python_type_field(self, typebld):
         return typebld.DefineField(
             "PythonType",
             PythonType,
             FieldAttributes.Public | FieldAttributes.Static)
 
     def set_python_type_field(self, new_type):
-        self.PythonType = new_type.GetField("PythonType")        
+        self.PythonType = new_type.GetField("PythonType")
         self.PythonType.SetValue(None, self)
 
     def add_wrapper_ctors(self, baseType, typebld):
         python_type_field = self.emit_python_type_field(typebld)
-        for ctor in baseType.GetConstructors(): 
+        for ctor in baseType.GetConstructors():
             ctorparams = ctor.GetParameters()
 
             # leave out the PythonType argument
@@ -500,19 +500,19 @@ def add_wrapper_ctors(self, baseType, typebld):
                 ilgen.Emit(OpCodes.Ldarg, index + 1)
             ilgen.Emit(OpCodes.Call, ctor)
             ilgen.Emit(OpCodes.Ret)
-    
+
     def emit_members(self, typebld):
         self.emit_fields(typebld)
         self.add_wrapper_ctors(self.baseType, typebld)
         super(ClrClass, self).emit_members(typebld)
-        
+
     def map_members(self, new_type):
         self.map_fields(new_type)
         self.map_pinvoke_methods(new_type)
         self.set_python_type_field(new_type)
         super(ClrClass, self).map_members(new_type)
 
-    def __clrtype__(self):        
+    def __clrtype__(self):
         # CDerived below will use ClrClass as its metaclass, but the user may not expect CDerived
         # to be a typed .NET class in this case:
         #
@@ -522,9 +522,9 @@ def __clrtype__(self):
         if not "__metaclass__" in self.__dict__:
             return super(ClrClass, self).__clrtype__()
 
-        # Create a simple Python type first. 
+        # Create a simple Python type first.
         self.baseType = super(ClrType, self).__clrtype__()
-        # We will now subtype it to create a customized class with the 
+        # We will now subtype it to create a customized class with the
         # CLR attributes as defined by the user
         typegen = Snippets.Shared.DefineType(self.get_clr_type_name(), self.baseType, True, False)
         typebld = typegen.TypeBuilder
@@ -537,7 +537,7 @@ def make_cab(attrib_type, *args, **kwds):
 
     props = ([],[])
     fields = ([],[])
-    
+
     for kwd in kwds:
         pi = clrtype.GetProperty(kwd)
         if pi is not None:
@@ -550,9 +550,9 @@ def make_cab(attrib_type, *args, **kwds):
                 fields[1].append(kwds[kwd])
             else:
                 raise TypeError("No %s Member found on %s" % (kwd, clrtype.Name))
-    
-    return CustomAttributeBuilder(ci, args, 
-        tuple(props[0]), tuple(props[1]), 
+
+    return CustomAttributeBuilder(ci, args,
+        tuple(props[0]), tuple(props[1]),
         tuple(fields[0]), tuple(fields[1]))
 
 def accepts(*args):
@@ -582,11 +582,11 @@ class CustomAttributeDecorator(object):
     Note that we cannot use an instance of System.Attribute to capture this information
     as it is not possible to go from an instance of System.Attribute to an instance
     of System.Reflection.Emit.CustomAttributeBuilder as the latter needs to know
-    how to represent information in metadata to later *recreate* a similar instance of 
+    how to represent information in metadata to later *recreate* a similar instance of
     System.Attribute.
-    
+
     Also note that once a CustomAttributeBuilder is created, it is not possible to
-    query it. Hence, we need to store the arguments required to store the 
+    query it. Hence, we need to store the arguments required to store the
     CustomAttributeBuilder so that pseudo-custom-attributes can get to the information.
     """
     def __init__(self, attrib_type, *args, **kwargs):
@@ -629,4 +629,3 @@ def propagate_attributes(old_function, new_function):
         new_function.CustomAttributeBuilders = old_function.CustomAttributeBuilders
     if hasattr(old_function, "CustomAttributeBuilders"):
         new_function.DllImportAttributeDecorator = old_function.DllImportAttributeDecorator
-