Overide virtual methods for this extension. `this`       : is this Fancytree object `this._super`: the virtual function that was overridden (member of prev. extension or Fancytree)
1886
function(ctx){
		var tree = ctx.tree;

		// Bind init-handler to apply cookie state
		tree.$div.bind("fancytreeinit", function(event){
			tree.debug("COOKIE " + document.cookie);
		});
		// Init the tree
		this._super(ctx);
	}
79964
function inherits(subClass, superClass) {
  // if (typeof superClass !== "function" && superClass !== null) {
  //   throw new TypeError(
  //     "Super expression must either be null or a function, not " +
  //       typeof superClass
  //   );
  // }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true,
    },
  });
  // if (superClass)
  //   Object.setPrototypeOf
  //     ? Object.setPrototypeOf(subClass, superClass)
  //     : (subClass.__proto__ = superClass);
}
1143511
def inherited_meths(opts = {})
      inheritance_tree[1..-1].inject([]) do |list, superclass|
        if superclass.is_a?(Proxy)
          list
        else
          list += superclass.meths(opts).reject do |o|
            next(false) if opts[:all]
            child(:name => o.name, :scope => o.scope) ||
              list.find {|o2| o2.name == o.name && o2.scope == o.scope }
          end
        end
      end
    end
55583
function afterExtends (klass, baseKlass, superFunc) {
    var newKlass = createNamedClass(klass.name, klass, baseKlass, superFunc);
    newKlass.prototype = createPrototype(klass, baseKlass, newKlass);
    
    return newKlass;
}
1122137
def superclass=(object)
      case object
      when Base, Proxy, NilClass
        @superclass = object
      when String, Symbol
        @superclass = Proxy.new(namespace, object)
      else
        raise ArgumentError, "superclass must be CodeObject, Proxy, String or Symbol"
      end

      if name == @superclass.name && namespace != YARD::Registry.root && !object.is_a?(Base)
        @superclass = Proxy.new(namespace.namespace, object)
      end

      if @superclass == self
        msg = "superclass #{@superclass.inspect} cannot be the same as the declared class #{inspect}"
        @superclass = P("::Object")
        raise ArgumentError, msg
      end
    end
1213823
public static boolean isSuperCall(JCTree tree) {
        Name name = calledMethodName(tree);
        if (name != null) {
            Names names = name.table.names;
            return name==names._super;
        } else {
            return false;
        }
    }
1163430
function() {
      return extend(this.callSuper('toObject'), {
        x1: this.get('x1'),
        y1: this.get('y1'),
        x2: this.get('x2'),
        y2: this.get('y2')
      });
    }
790187
function unherit(Super) {
  var result
  var key
  var value

  inherits(Of, Super)
  inherits(From, Of)

  /* Clone values. */
  result = Of.prototype

  for (key in result) {
    value = result[key]

    if (value && typeof value === 'object') {
      result[key] = 'concat' in value ? value.concat() : xtend(value)
    }
  }

  return Of

  /* Constructor accepting a single argument,
   * which itself is an `arguments` object. */
  function From(parameters) {
    return Super.apply(this, parameters)
  }

  /* Constructor accepting variadic arguments. */
  function Of() {
    if (!(this instanceof Of)) {
      return new From(arguments)
    }

    return Super.apply(this, arguments)
  }
}
170059
def do_super(parser, token):
    '''
    
    '''
    name = token.strip()
    return ast.YieldFrom(
        value=_a.Call(_a.Attribute(_a.Call(_a.Name('super')), name), [
            # _a.Attribute(_a.Name('context'), 'parent'),
            _a.Name('context'),
        ])
    )
1140943
function() {
  var fn = this.__superFunction;
  var self = this;
  var bound = function _super() {
    if (this && this !== self) {
      throw new Error('_super cannot change `this` use _super.unbound');
    }
    return fn && fn.apply(self, arguments);
  };
  return _.extend(bound, { unbound: fn });
}
465830
def override(cls):
    

    def check_override(method):
        if method.__name__ not in dir(cls):
            raise NameError("{} does not override any method of {}".format(
                method, cls))
        return method

    return check_override
1106027
def has_superclass?(child, ancestor)
      if child.superclass == ancestor
        true
      elsif child.superclass.nil?
        false
      else
        has_superclass?(child.superclass, ancestor)
      end
    end
846914
function overrideLocEnd(toBeOverriddenNode, toOverrideNode) {
    if (options.originalText[locEnd(toOverrideNode)] === ";") {
      return;
    }
    if (options.parser === "flow") {
      toBeOverriddenNode.range = [
        toBeOverriddenNode.range[0],
        toOverrideNode.range[1]
      ];
    } else {
      toBeOverriddenNode.end = toOverrideNode.end;
    }
    toBeOverriddenNode.loc = Object.assign({}, toBeOverriddenNode.loc, {
      end: toBeOverriddenNode.loc.end
    });
  }
142869
function () {
      this._super.apply(this, arguments);
      var name = arguments[0];
      var method = this[name];
      if (method) {
        var length = arguments.length;
        var args = new Array(length - 1);
        for (var i = 1; i < length; i++) {
          args[i - 1] = arguments[i];
        }
        return method.apply(this, args);
      }
    }
549996
private void tryReplaceSuper(Node superNode) {
    checkState(!superclasses.isEmpty(), "`super` cannot appear outside a function");
    Optional<Node> currentSuperclass = superclasses.peek();
    if (!currentSuperclass.isPresent() || !currentSuperclass.get().isQualifiedName()) {
      // either if a) we're in a static class fn without an 'extends' clause or b) we're not in
      // a static class function
      return;
    }

    Node fullyQualifiedSuperRef = currentSuperclass.get().cloneTree();
    superNode.replaceWith(fullyQualifiedSuperRef);
    compiler.reportChangeToEnclosingScope(fullyQualifiedSuperRef);
  }
1093959
def overrides(method):
    '''
    
    '''
    def wrapper(func):
        if func.__name__ != method.__name__:
            msg = "Wrong @override: %r expected, but overwriting %r."
            msg = msg % (func.__name__, method.__name__)
            raise AssertionError(msg)

        if func.__doc__ is None:
            func.__doc__ = method.__doc__

        return func

    return wrapper
485202
def locate_set_var(var, override)

      hk = h.variables && h.variables.has_key?(var)

      if ( ! override) || var.match(/^\//)
        false
      elsif override == 'sub' && DefineExpression.is_definition?(tree) && ! hk
        false
      elsif hk
        [ self, var ]
      elsif par = parent
        par.locate_set_var(var, override)
      else
        false
      end
    end