--- a/ipc/ipdl/ipdl/cxx/ast.py
+++ b/ipc/ipdl/ipdl/cxx/ast.py
@@ -477,55 +477,51 @@ def make_enum(name, members_str):
         member_value += 1
     return type(name, (), members_dict)
 
 MethodSpec = make_enum('MethodSpec', 'NONE VIRTUAL PURE OVERRIDE STATIC')
 
 class MethodDecl(Node):
     def __init__(self, name, params=[ ], ret=Type('void'),
                  methodspec=MethodSpec.NONE, const=0, warn_unused=0,
-                 inline=0, force_inline=0, never_inline=0,
+                 inline=0, force_inline=0,
                  typeop=None, T=None):
         assert not (name and typeop)
         assert name is None or isinstance(name, str)
         assert not isinstance(ret, list)
         for decl in params:  assert not isinstance(decl, str)
         assert not isinstance(T, int)
-        assert not (inline and never_inline)
-        assert not (force_inline and never_inline)
 
         if typeop is not None:
             assert methodspec == MethodSpec.NONE
             ret = None
 
         Node.__init__(self)
         self.name = name
         self.params = params            # [ Param ]
         self.ret = ret                  # Type or None
         self.methodspec = methodspec    # enum
         self.const = const              # bool
         self.warn_unused = warn_unused  # bool
         self.force_inline = (force_inline or T) # bool
         self.inline = inline            # bool
-        self.never_inline = never_inline # bool
         self.typeop = typeop            # Type or None
         self.T = T                      # Type or None
         self.only_for_definition = False
 
     def __deepcopy__(self, memo):
         return MethodDecl(
             self.name,
             params=copy.deepcopy(self.params, memo),
             ret=copy.deepcopy(self.ret, memo),
             methodspec=self.methodspec,
             const=self.const,
             warn_unused=self.warn_unused,
             inline=self.inline,
             force_inline=self.force_inline,
-            never_inline=self.never_inline,
             typeop=copy.deepcopy(self.typeop, memo),
             T=copy.deepcopy(self.T, memo))
 
 class MethodDefn(Block):
     def __init__(self, decl):
         Block.__init__(self)
         self.decl = decl
 

--- a/ipc/ipdl/ipdl/cxx/cgen.py
+++ b/ipc/ipdl/ipdl/cxx/cgen.py
@@ -197,18 +197,16 @@ class CxxCodeGen(CodePrinter, Visitor):
             md.T.accept(self)
             self.println('>')
             self.printdent()
 
         if md.warn_unused:
             self.write('MOZ_MUST_USE ')
         if md.inline:
             self.write('inline ')
-        if md.never_inline:
-            self.write('MOZ_NEVER_INLINE ')
 
         if md.methodspec == MethodSpec.STATIC:
             self.write('static ')
         elif md.methodspec == MethodSpec.VIRTUAL or \
              md.methodspec == MethodSpec.PURE:
             self.write('virtual ')
 
         if md.ret:

--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -4895,17 +4895,16 @@ methodDefns."""
 
     return cls, defns
 
 def _splitMethodDefn(md, clsname):
     saveddecl = deepcopy(md.decl)
     md.decl.name = (clsname +'::'+ md.decl.name)
     md.decl.methodspec = MethodSpec.NONE
     md.decl.warn_unused = 0
-    md.decl.never_inline = 0
     md.decl.only_for_definition = True
     for param in md.decl.params:
         if isinstance(param, Param):
             param.default = None
     return saveddecl, md
 
 
 def _splitFuncDeclDefn(fun):