Placing this in execute because then subclass handle() don't have to call super
765285
def execute(self, *args, **options):
        ''''''
        if options['verbose']:
            options['verbosity'] = 3
        if options['quiet']:
            options['verbosity'] = 0
        self.verbosity = options.get('verbosity', 1)
        super().execute(*args, **options)
621602
@Override
	public void visitMethodInsn(final int opcode, final String owner, final String name, final String desc,
			boolean itf) {
		// If this is an invokespecial, first determine if it is the one of interest (the one calling our super constructor)
		if (opcode == INVOKESPECIAL && name.charAt(0) == '<') {
			if (unitializedObjectsCount != 0) {
				unitializedObjectsCount--;
			}
			else {
				// This looks like our INVOKESPECIAL
				if (state == preInvokeSpecial) {
					// special case for calling jlObject, do nothing!
					if (owner.equals("java/lang/Object")) {
						mv.visitInsn(POP);
					}
					else {
						// Need to replace this INVOKESPECIAL call.
						String supertypename = typeDescriptor.getSupertypeName();
						ReloadableType superRtype = typeDescriptor.getReloadableType().getTypeRegistry().getReloadableSuperType(
								supertypename);
						if (superRtype == null) {
							// supertype was not reloadable.  This either means it really isn't (doesn't match what we consider reloadable)
							// or it just hasn't been loaded yet.
							// In a real scenario supertypes will get loaded first always and this can't happen (the latter case) - it happens in tests
							// because they don't actively load all their bits and pieces in a hierarchical way.  Given that on a reloadable boundary
							// the magic ctors are setup to call a default ctor, we can assume that above the boundary the object has been initialized.
							// this means we don't need to call a super __init__ or __execute...
							/*
																	if (typeDescriptor.getReloadableType().getTypeRegistry().isReloadableTypeName(supertypename)) {
																					superRtype = typeDescriptor.getReloadableType().getTypeRegistry()
																								.getReloadableSuperType(supertypename);
																						throw new IllegalStateException("The supertype " + supertypename.replace('/', '.')
																								+ " has not been loaded as a reloadabletype");
																					}
																					*/
							Utils.insertPopsForAllParameters(mv, desc);
							mv.visitInsn(POP); // pop 'this'
						}
						else {
							// Check the original form of the supertype for a constructor to call
							MethodMember existingCtor = (superRtype == null ? null
									: superRtype.getTypeDescriptor().getConstructor(
											desc));
							if (existingCtor == null) {
								// It did not exist in the original supertype version, need to use dynamic dispatch method
								// collapse the arguments on the stack
								Utils.collapseStackToArray(mv, desc);
								// now the stack is the instance then the params
								mv.visitInsn(SWAP);
								mv.visitInsn(DUP_X1);
								// no stack is instance then params then instance
								mv.visitLdcInsn("<init>" + desc);
								mv.visitMethodInsn(INVOKESPECIAL, typeDescriptor.getSupertypeName(),
										mDynamicDispatchName,
										mDynamicDispatchDescriptor, false);
								mv.visitInsn(POP);
							}
							else {
								// it did exist in the original, so there will be parallel constructor
								mv.visitMethodInsn(INVOKESPECIAL, typeDescriptor.getSupertypeName(), mInitializerName,
										desc, false);
							}
						}
					}

					state = postInvokeSpecial;

					return;
				}
			}
		}
		// Is it a private method call?
		// TODO r$ check here because we use invokespecial to avoid virtual dispatch on field changes...
		if (opcode == INVOKESPECIAL && name.charAt(0) != '<' && owner.equals(classname) && !name.startsWith("r$")) {
			// leaving the invokespecial alone will cause a verify error
			String descriptor = Utils.insertExtraParameter(owner, desc);
			super.visitMethodInsn(INVOKESTATIC, Utils.getExecutorName(classname, suffix), name, descriptor, false);
		}
		else {
			boolean done = false;
			// TODO dup of code in method copier - can we refactor?
			if (opcode == INVOKESTATIC) {
				MethodMember mm = typeDescriptor.getByDescriptor(name, desc);
				if (mm != null && mm.isPrivate()) {
					super.visitMethodInsn(INVOKESTATIC, Utils.getExecutorName(classname, suffix), name, desc, false);
					done = true;
				}
			}
			if (!done) {
				super.visitMethodInsn(opcode, owner, name, desc, itf);
			}
		}
	}
820155
function SubClass() {
		var ret;
		// Call the parent constructor.
		parent.apply(this, arguments);

		// Only call initialize in self constructor.
		if(this.constructor === SubClass && this.initialize) {
			ret = this.initialize.apply(this, arguments);
		}
		return ret ? ret : this;
	}
1024509
public int executeRaw(DatabaseConnection connection, String statement, String[] arguments) throws SQLException {
		logger.debug("running raw execute statement: {}", statement);
		if (arguments.length > 0) {
			// need to do the (Object) cast to force args to be a single object
			logger.trace("execute arguments: {}", (Object) arguments);
		}
		CompiledStatement compiledStatement = connection.compileStatement(statement, StatementType.EXECUTE,
				noFieldTypes, DatabaseConnection.DEFAULT_RESULT_FLAGS, false);
		try {
			assignStatementArguments(compiledStatement, arguments);
			return compiledStatement.runExecute();
		} finally {
			IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
		}
	}
1303255
function _super(methodName, args) {
	// Keep track of how far up the prototype chain we have traversed,
	// in order to handle nested calls to _super.
	if (this._superCallObjects === undefined) { this._superCallObjects = {}; }
	var oldSuperCallback = this._superCallObjects[methodName],
		currentObject = oldSuperCallback || this,
		parentObject  = findSuper(methodName, currentObject),
		result;
	this._superCallObjects[methodName] = parentObject;

	try {
		result = parentObject[methodName].apply(this, args || []);
	} finally {
		if (oldSuperCallback) {
			this._superCallObjects[methodName] = oldSuperCallback;
		} else {
			delete this._superCallObjects[methodName];
		}
	}
	return result;
}
1373140
void handlePut(SimpleTest test, Conjunction selector, MatchTarget object,
                 InternTable subExpr) throws MatchingException
  {

    if (tc.isEntryEnabled())
	  tc.entry(this,cclass, "handlePut",
               new Object[] {test,selector,object, subExpr}	
	  );
    Object value = test.getValue();
    if (value != null)
      // equality test.
      handleEqualityPut(new Wrapper(value), selector, object, subExpr);
    else {  
      // Inequality or range, goes in CheapRangeTable
      ContentMatcher next = (ContentMatcher) ranges.getExact(test);
      // Create a new Matcher if called for
      ContentMatcher newNext = nextMatcher(selector, next);
      // Record the subscription
      newNext.put(selector, object, subExpr);
      // See if Matcher must be replaced, and, in that case, where.
      if (newNext != next)
        if (next == null)
          ranges.insert(test, newNext);
        else
          ranges.replace(test, newNext);
    }
    if (tc.isEntryEnabled())
	  tc.exit(this,cclass, "handlePut");        
  }
313654
function initHandlers(options, handlerClass) {
    var optHandlers = Array.isArray(options[handlerClass]) ?
          options[handlerClass] : [options[handlerClass]],
      handlers = [];
    optHandlers.forEach(function(handler) {
      if (typeof handler === 'function') {
        handlers.push(handler);
      } else if (typeof handler === 'string' && builtinHandler[handlerClass][handler]) {
        handlers.push(builtinHandler[handlerClass][handler]);
      }
    });
    return handlers;
  }
547776
@Nonnull
	public final LObjIntCharFunctionBuilder<T, R> withHandling(@Nonnull HandlingInstructions<RuntimeException, RuntimeException> handling) {
		Null.nonNullArg(handling, "handling");
		if (this.handling != null) {
			throw new UnsupportedOperationException("Handling is already set for this builder.");
		}
		this.handling = handling;
		return self();
	}
685171
@Override
    public Object handle(Message msg) throws Exception {
        if(req_handler != null)
            return req_handler.handle(msg);
        return null;
    }
228135
void handleRemove(SimpleTest test, Conjunction selector,
                    MatchTarget object, InternTable subExpr, OrdinalPosition parentId) throws MatchingException
  {
    if (tc.isEntryEnabled())
	    tc.entry(this,cclass, "handleRemove","test: "+test+ ",selector: "+selector+", object: "+object);
	    	
    if (test.getKind() == SimpleTest.ID)
      trueChild = trueChild.remove(selector, object, subExpr, ordinalPosition);
    else if (test.getKind() == SimpleTest.NOTID)
      falseChild = falseChild.remove(selector, object, subExpr, ordinalPosition);
    else
      throw new IllegalStateException();

    if (tc.isEntryEnabled())
	    tc.exit(this,cclass, "handleRemove");      
  }
566731
private Status executeSkip(Stmt.Skip stmt, CallStack frame, EnclosingScope scope) {
		// skip !
		return Status.NEXT;
	}
1235435
function replaceSuperMethodCall(node, state, path, options) {
  // like super.foo()
  console.assert(node.type === "CallExpression");
  console.assert(node.callee.object.type === "Super");

  return funcCall(
            member(
              funcCall(
                member(options.functionNode, "_get"),
                replaceSuper(node.callee.object, state, path.concat(["callee", "object"]), options),
                literal(node.callee.property.value || node.callee.property.name),
                id("this")),
                "call"),
            id("this"), ...node.arguments);
}
684711
function BaseTypeHandler(ksTypeName, handlers) {
    this.ksTypeName = ksTypeName;

    if ("function" === typeof handlers) {
        this.handlers = {default: handlers};
    }
    else {
        this.handlers = _.extend({}, handlers);
    }

}
949128
function(C, SuperC) {
		C.$super = null; // what's this?
		C.$subclasses = [];
		C.$superclass = SuperC || null;
		C.$recurring = SuperC ?
			gui.Object.copy(SuperC.$recurring) : Object.create(null);
		if (SuperC) {
			SuperC.$subclasses.push(C);
		}
		return C;
	}
388284
function(SuperC, proto, name) {
		name = name || gui.Class.ANONYMOUS;
		// TODO: this in devmode if and when we might know the name beforehand
		// C = gui.Function.create ( name, null, this._namedbody ( name ));
		var C = function $Class() {
			if (this instanceof $Class) {
				return gui.Class.$constructor.apply(this, arguments);
			} else {
				return $Class.extend.apply($Class, arguments);
			}
		};
		C.$classid = gui.KeyMaster.generateKey("class");
		C.prototype = Object.create(proto || null);
		C.prototype.constructor = C;
		C = this._internals(C, SuperC);
		C = this._interface(C);
		C = this._classname(C, name);
		return C;
	}
33064
private void handleArgInputHandler(final Deque<String> args) {
        if (inputHandlerClassname != null) {
            throw new BuildException("Only one input handler class may be specified.");
        }
        inputHandlerClassname = args.pop();
        if (inputHandlerClassname == null) {
            throw new BuildException("You must specify a classname when using the --inputhandler" + " argument");
        }
    }
277287
@Override
    public void handle() throws HandlerException {
        String repository = getAuditEvent().getRepository();
        boolean writeInDefaultTable = !separate || repository == null;
        String tableName = writeInDefaultTable ? default_table_name : generateTableName(repository);

        getDaoForTable(tableName).writeEvent(getAuditEvent());
    }