Bugfix 1183

src/nodes.coffee

@@ -496,7 +496,9 @@ exports.Call = class Call extends Base
   # Grab the reference to the superclass's implementation of the current
   # method.
   superReference: (o) ->
-    {method} = o.scope
+    # Keep walking up the scope chain until we find the original reference
+    # to a method.  Stop at the first one.
+    method = o.scope.getMethodRecurse()
     throw SyntaxError 'cannot call super outside of a function.' unless method
     {name} = method
     throw SyntaxError 'cannot call super on an anonymous function.' unless name?
@@ -508,6 +510,9 @@ exports.Call = class Call extends Base
     else
       "#{name}.__super__.constructor"
 
+  superThis : (o) ->
+    if o.scope?.method?.context? then o.scope.method.context else "this"
+
   # Soaked chained invocations unfold into if/else ternary structures.
   unfoldSoak: (o) ->
     if @soak
@@ -566,21 +571,21 @@ exports.Call = class Call extends Base
     args = @filterImplicitObjects @args
     args = (arg.compile o, LEVEL_LIST for arg in args).join ', '
     if @isSuper
-      @superReference(o) + ".call(this#{ args and ', ' + args })"
+      @superReference(o) + ".call(#{@superThis o}#{ args and ', ' + args })"
     else
       (if @isNew then 'new ' else '') + @variable.compile(o, LEVEL_ACCESS) + "(#{args})"
 
   # `super()` is converted into a call against the superclass's implementation
   # of the current function.
   compileSuper: (args, o) ->
-    "#{@superReference(o)}.call(this#{ if args.length then ', ' else '' }#{args})"
+    "#{@superReference(o)}.call(#{@superThis o}#{ if args.length then ', ' else '' }#{args})"
 
   # If you call a function with a splat, it's converted into a JavaScript
   # `.apply()` call to allow an array of arguments to be passed.
   # If it's a constructor, then things get real tricky. We have to inject an
   # inner constructor in order to be able to pass the varargs.
   compileSplat: (o, splatArgs) ->
-    return "#{ @superReference o }.apply(this, #{splatArgs})" if @isSuper
+    return "#{ @superReference o }.apply(#{@superThis o}, #{splatArgs})" if @isSuper
     if @isNew
       idt = @tab + TAB
       return """
@@ -1924,7 +1929,8 @@ Closure =
 
   literalThis: (node) ->
     (node instanceof Literal and node.value is 'this' and not node.asKey) or
-      (node instanceof Code and node.bound)
+      (node instanceof Code and node.bound) or
+      (node instanceof Call and node.isSuper)
 
 # Unfold a node's child if soak, then tuck the node under created `If`
 unfoldSoak = (o, parent, name) ->

src/scope.coffee

@@ -30,6 +30,18 @@ exports.Scope = class Scope
     else
       @positions[name] = @variables.push({name, type}) - 1
 
+  # When `super somearg` is called, we need to find the name of the current
+  # method we're in, so we know how to address the same method of the
+  # super class.  This can get complicated if super is being called
+  # from a closure.  getMethodRecurse() will walk up the scope
+  # tree until it finds the first method object that has a name filled
+  # in.  It will return the topmost method object otherwise, which may
+  # be null if this is being called from outside a function.
+  getMethodRecurse: ->
+    if @method?.name? then @method
+    else if @parent then @parent.getMethodRecurse()
+    else @method # {} for a function, and null for a non-function
+
   # Look up a variable name in lexical scope, and declare it if it does not
   # already exist.
   find: (name, options) ->

test/scope.coffee

@@ -41,3 +41,35 @@ test "#1973: redefining Array/Object constructors shouldn't confuse __X helpers"
   obj = {arr}
   for own k of obj
     eq arr, obj[k]
+
+test "#1183: super + fat arrows", ->
+  dolater = (cb) -> cb()
+
+  class A
+  	constructor: ->
+  		@_i = 0
+  	foo : (cb) ->
+  		dolater => 
+  			@_i += 1 
+  			cb()
+
+  class B extends A
+  	constructor : ->
+  		super
+  	foo : (cb) ->
+  		dolater =>
+  			dolater =>
+  				@_i += 2
+  				super cb
+
+  b = new B()
+  b.foo => eq b._i, 3
+
+test "#1183: super + wrap", ->
+  class A
+    m : -> 10
+  class B extends A
+    constructor : -> super
+  B::m = -> r = try super()
+  eq (new B()).m(), 10
+