Merge pull request #2693 from Ms2ger/fix-indentation

Clean up the indentation of generated code.

src/components/script/dom/bindings/codegen/CodegenRust.py

@@ -168,7 +168,7 @@ class CGMethodCall(CGThing):
             # here for our one signature and not worry about switching
             # on anything.
             signature = signatures[0]
-            self.cgRoot = CGList([ CGIndenter(getPerSignatureCall(signature)) ])
+            self.cgRoot = CGList([getPerSignatureCall(signature)])
             requiredArgs = requiredArgCount(signature)
 
 
@@ -179,7 +179,7 @@ class CGMethodCall(CGThing):
                     "  return 0;\n"
                     "}" % (requiredArgs, methodName))
                 self.cgRoot.prepend(
-                    CGWrapper(CGIndenter(CGGeneric(code)), pre="\n", post="\n"))
+                    CGWrapper(CGGeneric(code), pre="\n", post="\n"))
                     
             return
 
@@ -359,7 +359,7 @@ class CGMethodCall(CGThing):
         #overloadCGThings.append(
         #    CGGeneric('fail!("We have an always-returning default case");\n'
         #              'return 0;'))
-        self.cgRoot = CGWrapper(CGIndenter(CGList(overloadCGThings, "\n")),
+        self.cgRoot = CGWrapper(CGList(overloadCGThings, "\n"),
                                 pre="\n")
 
     def define(self):
@@ -1709,19 +1709,21 @@ class CGAbstractMethod(CGThing):
 
     def _returnType(self):
         return (" -> %s" % self.returnType) if self.returnType != "void" else ""
-    def _unsafe_open(self):
-        return "\n  unsafe {\n" if self.unsafe else ""
-    def _unsafe_close(self):
-        return "\n  }\n" if self.unsafe else ""
 
     def define(self):
-        return self.definition_prologue() + "\n" + self.definition_body() + self.definition_epilogue()
+        body = self.definition_body()
+        if self.unsafe:
+            body = CGWrapper(body, pre="unsafe {\n", post="\n}")
+
+        return CGWrapper(CGIndenter(body),
+                         pre=self.definition_prologue(),
+                         post=self.definition_epilogue()).define()
 
     def definition_prologue(self):
-        return "%sfn %s%s(%s)%s {%s" % (self._decorators(), self.name, self._template(),
+        return "%sfn %s%s(%s)%s {\n" % (self._decorators(), self.name, self._template(),
-                                        self._argstring(), self._returnType(), self._unsafe_open())
+                                          self._argstring(), self._returnType())
     def definition_epilogue(self):
-        return "%s}\n" % self._unsafe_close()
+        return "\n}\n"
     def definition_body(self):
         assert(False) # Override me!
 
@@ -1770,7 +1772,7 @@ class CGWrapMethod(CGAbstractMethod):
 
     def definition_body(self):
         if not self.descriptor.createGlobal:
-            return """
+            return CGGeneric("""\
 let scope = aScope.reflector().get_jsobject();
 assert!(scope.is_not_null());
 assert!(((*JS_GetClass(scope)).flags & JSCLASS_IS_GLOBAL) != 0);
@@ -1782,16 +1784,16 @@ class CGWrapMethod(CGAbstractMethod):
 
 raw.reflector().set_jsobject(obj);
 
-  return raw;""" % CreateBindingJSObject(self.descriptor, "scope")
+return raw;""" % CreateBindingJSObject(self.descriptor, "scope"))
         else:
-            return """
+            return CGGeneric("""\
 %s
 with_compartment(aCx, obj, || {
   let proto = GetProtoObject(aCx, obj, obj);
   JS_SetPrototype(aCx, obj, proto);
 });
 raw.reflector().set_jsobject(obj);
-  return raw;""" % CreateBindingJSObject(self.descriptor)
+return raw;""" % CreateBindingJSObject(self.descriptor))
 
 
 class CGIDLInterface(CGThing):
@@ -1920,12 +1922,10 @@ class CGCreateInterfaceObjectsMethod(CGAbstractMethod):
             arrayPtr("methods"), arrayPtr("attrs"),
             arrayPtr("consts"), arrayPtr("staticMethods"))
 
-        functionBody = CGList(
+        return CGList([
-            [CGGeneric(getParentProto),
+            CGGeneric(getParentProto),
-             CGGeneric(call % self.properties.variableNames())],
+            CGGeneric(call % self.properties.variableNames())
-            "\n\n")
+        ], "\n")
-        #return CGIndenter(CGWrapper(functionBody, pre="/*", post="*/return ptr::null()")).define()
-        return CGIndenter(functionBody).define()
 
 class CGGetPerInterfaceObject(CGAbstractMethod):
     """
@@ -1939,7 +1939,7 @@ class CGGetPerInterfaceObject(CGAbstractMethod):
                                   '*mut JSObject', args, pub=pub)
         self.id = idPrefix + "id::" + self.descriptor.name
     def definition_body(self):
-        return """
+        return CGGeneric("""
 
 /* aGlobal and aReceiver are usually the same, but they can be different
    too. For example a sandbox often has an xray wrapper for a window as the
@@ -1959,7 +1959,7 @@ class CGGetPerInterfaceObject(CGAbstractMethod):
   tmp
 } else {
   cachedObject
-  }""" % (self.id, self.id)
+}""" % (self.id, self.id))
 
 class CGGetProtoObjectMethod(CGGetPerInterfaceObject):
     """
@@ -1969,9 +1969,12 @@ class CGGetProtoObjectMethod(CGGetPerInterfaceObject):
         CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObject",
                                          "PrototypeList::", pub=True)
     def definition_body(self):
-        return """
+        return CGList([
+            CGGeneric("""\
 /* Get the interface prototype object for this class.  This will create the
-     object as needed. */""" + CGGetPerInterfaceObject.definition_body(self)
+   object as needed. */"""),
+            CGGetPerInterfaceObject.definition_body(self),
+        ])
 
 class CGGetConstructorObjectMethod(CGGetPerInterfaceObject):
     """
@@ -1981,9 +1984,12 @@ class CGGetConstructorObjectMethod(CGGetPerInterfaceObject):
         CGGetPerInterfaceObject.__init__(self, descriptor, "GetConstructorObject",
                                          "constructors::")
     def definition_body(self):
-        return """
+        return CGList([
+            CGGeneric("""\
 /* Get the interface object for this class.  This will create the object as
-     needed. */""" + CGGetPerInterfaceObject.definition_body(self)
+   needed. */"""),
+            CGGetPerInterfaceObject.definition_body(self),
+        ])
 
 class CGDefineDOMInterfaceMethod(CGAbstractMethod):
     """
@@ -2001,10 +2007,10 @@ class CGDefineDOMInterfaceMethod(CGAbstractMethod):
         return CGAbstractMethod.define(self)
 
     def definition_body(self):
-        body = ""
+        body = CGList([])
         #XXXjdm This self.descriptor.concrete check shouldn't be necessary
         if not self.descriptor.concrete or self.descriptor.proxy:
-            body += """  let traps = ProxyTraps {
+            body.append(CGGeneric("""let traps = ProxyTraps {
   getPropertyDescriptor: Some(getPropertyDescriptor),
   getOwnPropertyDescriptor: Some(getOwnPropertyDescriptor),
   defineProperty: Some(defineProperty),
@@ -2040,13 +2046,13 @@ class CGDefineDOMInterfaceMethod(CGAbstractMethod):
 
 """ % (FINALIZE_HOOK_NAME,
        TRACE_HOOK_NAME,
-       self.descriptor.name)
+       self.descriptor.name)))
 
         if self.descriptor.interface.hasInterfaceObject():
-            body += """  let cx = (**js_info.js_context).ptr;
+            body.append(CGGeneric("""let cx = (**js_info.js_context).ptr;
 let global = window.reflector().get_jsobject();
 assert!(global.is_not_null());
-  assert!(GetProtoObject(cx, global, global).is_not_null());"""
+assert!(GetProtoObject(cx, global, global).is_not_null());"""))
 
         return body
 
@@ -2337,14 +2343,14 @@ class CGAbstractBindingMethod(CGAbstractExternMethod):
         unwrapThis = str(CastableObjectUnwrapper(
                         FakeCastableDescriptor(self.descriptor),
                         "obj", self.unwrapFailureCode))
-        unwrapThis = CGIndenter(
+        unwrapThis = CGGeneric(
-            CGGeneric("let obj: *mut JSObject = JS_THIS_OBJECT(cx, vp as *mut JSVal);\n"
+            "let obj: *mut JSObject = JS_THIS_OBJECT(cx, vp as *mut JSVal);\n"
             "if obj.is_null() {\n"
             "  return false as JSBool;\n"
             "}\n"
             "\n"
-                      "let this: JS<%s> = %s;\n" % (self.descriptor.concreteType, unwrapThis)))
+            "let this: JS<%s> = %s;\n" % (self.descriptor.concreteType, unwrapThis))
-        return CGList([ unwrapThis, self.generate_code() ], "\n").define()
+        return CGList([ unwrapThis, self.generate_code() ], "\n")
 
     def generate_code(self):
         assert(False) # Override me
@@ -2359,9 +2365,9 @@ class CGGenericMethod(CGAbstractBindingMethod):
         CGAbstractBindingMethod.__init__(self, descriptor, 'genericMethod', args)
 
     def generate_code(self):
-        return CGIndenter(CGGeneric(
+        return CGGeneric(
             "let _info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));\n"
-            "return CallJitMethodOp(_info, cx, obj, this.unsafe_get() as *libc::c_void, argc, vp);"))
+            "return CallJitMethodOp(_info, cx, obj, this.unsafe_get() as *libc::c_void, argc, vp);")
 
 class CGSpecializedMethod(CGAbstractExternMethod):
     """
@@ -2380,8 +2386,8 @@ class CGSpecializedMethod(CGAbstractExternMethod):
         name = self.method.identifier.name
         return CGWrapper(CGMethodCall([], MakeNativeName(name), self.method.isStatic(),
                                       self.descriptor, self.method),
-                         pre="  let this = JS::from_raw(this);\n" +
+                         pre="let this = JS::from_raw(this);\n"
-                             "  let mut this = this.root();\n").define()
+                             "let mut this = this.root();\n")
 
 class CGGenericGetter(CGAbstractBindingMethod):
     """
@@ -2403,9 +2409,9 @@ class CGGenericGetter(CGAbstractBindingMethod):
                                          unwrapFailureCode)
 
     def generate_code(self):
-        return CGIndenter(CGGeneric(
+        return CGGeneric(
             "let info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));\n"
-            "return CallJitPropertyOp(info, cx, obj, this.unsafe_get() as *libc::c_void, vp);\n"))
+            "return CallJitPropertyOp(info, cx, obj, this.unsafe_get() as *libc::c_void, vp);\n")
 
 class CGSpecializedGetter(CGAbstractExternMethod):
     """
@@ -2429,10 +2435,10 @@ class CGSpecializedGetter(CGAbstractExternMethod):
                                                             getter=True))
         if self.attr.type.nullable() or not infallible:
             nativeName = "Get" + nativeName
-        return CGWrapper(CGIndenter(CGGetterCall([], self.attr.type, nativeName,
+        return CGWrapper(CGGetterCall([], self.attr.type, nativeName,
-                                                 self.descriptor, self.attr)),
+                                      self.descriptor, self.attr),
-                         pre="  let this = JS::from_raw(this);\n" +
+                         pre="let this = JS::from_raw(this);\n"
-                             "  let mut this = this.root();\n").define()
+                             "let mut this = this.root();\n")
 
 class CGGenericSetter(CGAbstractBindingMethod):
     """
@@ -2453,7 +2459,7 @@ class CGGenericSetter(CGAbstractBindingMethod):
                                          unwrapFailureCode)
 
     def generate_code(self):
-        return CGIndenter(CGGeneric(
+        return CGGeneric(
                 "let mut undef = UndefinedValue();\n"
                 "let argv: *mut JSVal = if argc != 0 { JS_ARGV(cx, vp) } else { &mut undef as *mut JSVal };\n"
                 "let info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));\n"
@@ -2461,7 +2467,7 @@ class CGGenericSetter(CGAbstractBindingMethod):
                 "  return 0;\n"
                 "}\n"
                 "*vp = UndefinedValue();\n"
-                "return 1;"))
+                "return 1;")
 
 class CGSpecializedSetter(CGAbstractExternMethod):
     """
@@ -2479,11 +2485,11 @@ class CGSpecializedSetter(CGAbstractExternMethod):
 
     def definition_body(self):
         name = self.attr.identifier.name
-        return CGWrapper(CGIndenter(CGSetterCall([], self.attr.type,
+        return CGWrapper(CGSetterCall([], self.attr.type,
                                       "Set" + MakeNativeName(name),
-                                                 self.descriptor, self.attr)),
+                                      self.descriptor, self.attr),
-                         pre="  let this = JS::from_raw(this);\n" +
+                         pre="let this = JS::from_raw(this);\n"
-                             "  let mut this = this.root();\n").define()
+                             "let mut this = this.root();\n")
 
 
 class CGMemberJITInfo(CGThing):
@@ -3388,12 +3394,12 @@ class CGProxyUnwrap(CGAbstractMethod):
         CGAbstractMethod.__init__(self, descriptor, "UnwrapProxy", '*' + descriptor.concreteType, args, alwaysInline=True)
 
     def definition_body(self):
-        return """  /*if (xpc::WrapperFactory::IsXrayWrapper(obj)) {
+        return CGGeneric("""/*if (xpc::WrapperFactory::IsXrayWrapper(obj)) {
   obj = js::UnwrapObject(obj);
 }*/
 //MOZ_ASSERT(IsProxy(obj));
 let box_ = GetProxyPrivate(obj).to_private() as *%s;
-  return box_;""" % (self.descriptor.concreteType)
+return box_;""" % self.descriptor.concreteType)
 
 class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
     def __init__(self, descriptor):
@@ -3490,7 +3496,7 @@ if expando.is_not_null() {
 return 1;"""
 
     def definition_body(self):
-        return self.getBody()
+        return CGGeneric(self.getBody())
 
 class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
     def __init__(self, descriptor):
@@ -3548,7 +3554,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
         return set + """return proxyhandler::defineProperty_(%s);""" % ", ".join(a.name for a in self.args)
 
     def definition_body(self):
-        return self.getBody()
+        return CGGeneric(self.getBody())
 
 class CGDOMJSProxyHandler_hasOwn(CGAbstractExternMethod):
     def __init__(self, descriptor):
@@ -3601,7 +3607,7 @@ if expando.is_not_null() {
 return 1;"""
 
     def definition_body(self):
-        return self.getBody()
+        return CGGeneric(self.getBody())
 
 class CGDOMJSProxyHandler_get(CGAbstractExternMethod):
     def __init__(self, descriptor):
@@ -3673,7 +3679,7 @@ if found {
 return 1;""" % (getIndexedOrExpando, getNamed)
 
     def definition_body(self):
-        return self.getBody()
+        return CGGeneric(self.getBody())
 
 class CGDOMJSProxyHandler_obj_toString(CGAbstractExternMethod):
     def __init__(self, descriptor):
@@ -3705,7 +3711,7 @@ return xpc_qsStringToJsstring(cx, result, &jsresult) ? jsresult : NULL;"""
 })""" % self.descriptor.name
 
     def definition_body(self):
-        return self.getBody()
+        return CGGeneric(self.getBody())
 
 class CGAbstractClassHook(CGAbstractExternMethod):
     """
@@ -3717,12 +3723,15 @@ class CGAbstractClassHook(CGAbstractExternMethod):
                                         args)
 
     def definition_body_prologue(self):
-        return """
+        return CGGeneric("""\
 let this: *%s = unwrap::<%s>(obj);
-""" % (self.descriptor.concreteType, self.descriptor.concreteType)
+""" % (self.descriptor.concreteType, self.descriptor.concreteType))
 
     def definition_body(self):
-        return self.definition_body_prologue() + self.generate_code()
+        return CGList([
+            self.definition_body_prologue(),
+            self.generate_code(),
+        ])
 
     def generate_code(self):
         # Override me
@@ -3745,7 +3754,7 @@ class CGClassTraceHook(CGAbstractClassHook):
                                      args)
 
     def generate_code(self):
-        return "  (*this).trace(%s);" % self.args[0].name
+        return CGGeneric("(*this).trace(%s);" % self.args[0].name)
 
 class CGClassConstructHook(CGAbstractExternMethod):
     """
@@ -3763,17 +3772,14 @@ class CGClassConstructHook(CGAbstractExternMethod):
         return CGAbstractExternMethod.define(self)
 
     def definition_body(self):
-        return self.generate_code()
+        preamble = CGGeneric("""\
-
-    def generate_code(self):
-        preamble = """
 let global = global_object_for_js_object(JS_CALLEE(cx, vp).to_object()).root();
 let obj = global.deref().reflector().get_jsobject();
-"""
+""")
         nativeName = MakeNativeName(self._ctor.identifier.name)
         callGenerator = CGMethodCall(["&global.root_ref()"], nativeName, True,
                                      self.descriptor, self._ctor)
-        return preamble + callGenerator.define();
+        return CGList([preamble, callGenerator])
 
 class CGClassFinalizeHook(CGAbstractClassHook):
     """
@@ -3785,7 +3791,7 @@ class CGClassFinalizeHook(CGAbstractClassHook):
                                      'void', args)
 
     def generate_code(self):
-        return CGIndenter(CGGeneric(finalizeHook(self.descriptor, self.name, self.args[0].name))).define()
+        return CGGeneric(finalizeHook(self.descriptor, self.name, self.args[0].name))
 
 class CGDOMJSProxyHandlerDOMClass(CGThing):
     def __init__(self, descriptor):
@@ -4107,13 +4113,11 @@ class CGRegisterProtos(CGAbstractMethod):
                                   unsafe=False, pub=True)
         self.config = config
 
-    def _registerProtos(self):
-        lines = ["  codegen::Bindings::%sBinding::DefineDOMInterface(window, js_info);" % desc.name
-                 for desc in self.config.getDescriptors(isCallback=False,
-                                                        register=True)]
-        return '\n'.join(lines) + '\n'
     def definition_body(self):
-        return self._registerProtos()
+        return CGList([
+            CGGeneric("codegen::Bindings::%sBinding::DefineDOMInterface(window, js_info);" % desc.name)
+            for desc in self.config.getDescriptors(isCallback=False, register=True)
+        ], "\n")
 
 class CGBindingRoot(CGThing):
     """