Make the given javascript callFrame the target for goto
@param [] targets array
@param {Debugger.CallFrame} node
515592
function _makeJSTarget(targets, callFrame) {
        var script = ScriptAgent.scriptWithId(callFrame.location.scriptId);
        if (script && script.url) {
            var url = script.url;
            url += ":" + callFrame.location.lineNumber + "," + callFrame.location.columnNumber;
            var name = callFrame.functionName;
            if (name === "") {
                name = "anonymous function";
            }
            var file = _fileFromURL(url);
            targets.push({"type": "js", "url": url, "name": name, "file": file});
        }
    }
548637
private void addArrayMethods(List<MethodNode> methods, ClassNode receiver, String name, ClassNode[] args) {
        if (args.length!=1) return;
        if (!receiver.isArray()) return;
        if (!isIntCategory(getUnwrapper(args[0]))) return;
        if ("getAt".equals(name)) {
            MethodNode node = new MethodNode(name, Opcodes.ACC_PUBLIC, receiver.getComponentType(), new Parameter[]{new Parameter(args[0],"arg")}, null, null);
            node.setDeclaringClass(receiver.redirect());
            methods.add(node);
        } else if ("setAt".equals(name)) {
            MethodNode node = new MethodNode(name, Opcodes.ACC_PUBLIC, VOID_TYPE, new Parameter[]{new Parameter(args[0],"arg")}, null, null);
            node.setDeclaringClass(receiver.redirect());
            methods.add(node);
        }
    }
1219708
private void visitArray(final ObjectGraphNode node) {
		if (node.getValue() instanceof Object[]) {
			Object[] array = (Object[]) node.getValue();

			for (int i = 0; i < array.length; i++) {
				String entryType = array[i] == null ? Object.class.getName() : array[i].getClass().
						getName();

				ObjectGraphNode childNode = new ObjectGraphNode(++nodeCount, "[" + i + "]",
						entryType, array[i]);
				node.add(childNode);
				visit(childNode);
			}
		} else {
			ObjectGraphNode childNode = new ObjectGraphNode(++nodeCount, "[primitive array]", node.
					getValue().getClass().getName(), node.getValue());
			node.add(childNode);
		}
	}
1306287
function ( target, callback ) {
            if ( typeof Array.prototype.map === 'function' ) {
                this.map = function ( target, callback ) {
                    if ( this.is(target) ) {
                        return target.map( callback );
                    } else {
                        throw new Error('[ixBand] "map()" ' + MSG_NOT_ARRAY);
                    }
                };
            } else {
                this.map = function ( target, callback ) {
                    if ( this.is(target) ) {
                        var tArray = target,
                            aryNum = tArray.length,
                            result = [], i;
    
                        for ( i = 0; i < aryNum; ++i ) {
                            var state = callback.call( this , tArray[i], i, tArray );
                            result.push( state );
                        }
                        return result;
                    } else {
                        throw new Error('[ixBand] "map()" ' + MSG_NOT_ARRAY);
                    }
                };
            }
    
            return this.map( target, callback );
        }
1172797
void setTargets(DatanodeDescriptor[] locs, long generationStamp) {
    setTargets(locs);
    if (locs == null) {
      targetGSs = null;
      return;
    }
    long[] targetGSs = new long[locs.length];
    for (int i=0; i<targetGSs.length; i++) {
      targetGSs[i] = generationStamp;
    }
    this.targetGSs = targetGSs;
  }
776269
public void startScanNode(SiteNode node) {
		Target target = new Target(node);
		target.setRecurse(true);
		this.startScan(target, null, null);
	}
22217
function( node, events ) {
            var specific = this.specific();

            pathFindEach.call( this, node, events, function (item) {
                
                if ( specific ) {
                    try {
                        pickValue.call(
                            this,
                            specific,
                            item,
                            function ( valueNode ) {
                                // console.log(' spec', valueNode );
                                if ( valueNode ) {
                                    this.child.exec({ node: item }, events );
                                }
                                else {
                                    // console.log('* BreakPath')
                                    throw new BreakPath();
                                }
                            },
                            End
                        );
                    }
                    catch (err) {
                        if (err instanceof BreakPath) {
                            throw new Break();
                        }
                    }
                }
                else {
                    this.child.exec({ node: item }, events );
                }
            });

        }
1019532
function(nodes) {
        for (var i = 0; i < nodes.length; i++) {
            if (nodes[i] instanceof RiakNode) {
                this.nodes.push(nodes[i]);
            }
        }
        return this;
    }
374777
function(target, skeleton) {
//            console.log("Applying change: "+JSON.stringify(skeleton));
            if (skeleton == null) {
                return false;
            }
            if (typeof skeleton != typeof target) {
                return false;
            }
            switch (typeof skeleton)
            {
                case 'string':
                case 'number':
                case 'boolean':
                    // gone too far
                    return false;
                case 'object':
                    if (skeleton instanceof Array)
                    {
                        // for now only support direct replacement/mutation of elements, skeleton is insufficient to describe splicing
                        if (target.length != skeleton.length) {
                            return false;
                        }
                        var changed = false;
                        for (var i=0; i<skeleton.length; i++) {
                            if (skeleton[i] == null) {
                                continue;
                            }
                            switch (typeof skeleton[i]) {
                                case 'string':
                                case 'number':
                                case 'boolean':
                                    changed = (target[i] != skeleton[i]) || changed;
                                    target[i] = skeleton[i];
                                    break;
                                case 'object':
                                    changed = deepApply(target[i], skeleton[i]) || changed;
                                    break;
                                default:
                                    throw 'Unrecognized type: '+(typeof skeleton[i]);
                            }
                        }
                        return changed;
                    }
                    else {
                        var changed = false;
                        for (var k in skeleton) {
                            if (skeleton.hasOwnProperty(k)) {
                                if (target.hasOwnProperty(k)) {
                                    if (skeleton[k] == null) {
                                        continue;
                                    }
                                    switch (typeof skeleton[k]) {
                                        case 'string':
                                        case 'number':
                                        case 'boolean':
                                            changed = target[k] != skeleton[k] || changed;
                                            target[k] = skeleton[k];
                                            break;
                                        case 'object':
                                            changed = deepApply(target[k], skeleton[k]) || changed;
                                            break;
                                        default:
                                            throw 'Unrecognized type: '+(typeof skeleton[k]);
                                    }
                                }
                                else {
                                    target[k] = skeleton[k];
                                }
                            }
                        }
                        return changed;
                    }
                    break;
                default:
                    throw 'Unrecognized type: '+(typeof incoming);
            }
        }
718107
function(target, noDefault) {
		var inst = this._getInst(target);
		if (inst && !inst.inline)
			this._setDateFromField(inst, noDefault);
		return (inst ? this._getDate(inst) : null);
	}
657403
@Override
    public void visit(NodeVisitor v) {
        if (v.visit(this)) {
            target.visit(v);
            for (AstNode arg : getArguments()) {
                arg.visit(v);
            }
            if (initializer != null) {
                initializer.visit(v);
            }
        }
    }
1224363
function parse_targets (targets) {
    debug('Parse: parse targets');
    for (let i = 0; i < targets.length; i++) {
        const target = targets[i];
        const name   = path.basename(target);
        if (is_special(name)) {
            special_targets.push(target);
            continue;
        }
        parse_target(target);
    }
}
376533
function parse (targets) {
    debug('Parse: start parsing');
    targets = prepare.targets(targets);
    prepare_babelrc();
    parse_targets(targets);
}
585344
function (target, f) {
      var r = [];

      var recurse = function (e) {
        r.push(e);
        return f(e);
      };

      var cur = f(target);
      do {
        cur = cur.bind(recurse);
      } while (cur.isSome());

      return r;
    }
1273251
function(target, event, callback, traditional) {
			if(_.type(target) === 'string' || _.type(target) === 'array') {
				var elements = _.type(target) === 'string'? $$(target) : target;
				
				elements.forEach(function(element) {
					_.event.bind(element, event, callback, traditional);
				});
			}
			else if(_.type(event) === 'string') {
				if(traditional) {
					target['on' + event] = callback;
				}
				else {
					target.addEventListener(event, callback, false);
				}
			}
			else if(_.type(event) === 'array') {
				for (var i=0; i<event.length; i++) {
					_.event.bind(target, event[i], callback, arguments[2]);
				}
			}
			else {
				for (var name in event) {
					_.event.bind(target, name, event[name], arguments[2]);
				}
			}
		}
941577
function patchCallbacks(target, targetName, method, callbacks) {
    var symbol = Zone.__symbol__(method);
    if (target[symbol]) {
        return;
    }
    var nativeDelegate = target[symbol] = target[method];
    target[method] = function (name, opts, options) {
        if (opts && opts.prototype) {
            callbacks.forEach(function (callback) {
                var source = targetName + "." + method + "::" + callback;
                var prototype = opts.prototype;
                if (prototype.hasOwnProperty(callback)) {
                    var descriptor = ObjectGetOwnPropertyDescriptor(prototype, callback);
                    if (descriptor && descriptor.value) {
                        descriptor.value = wrapWithCurrentZone(descriptor.value, source);
                        _redefineProperty(opts.prototype, callback, descriptor);
                    }
                    else if (prototype[callback]) {
                        prototype[callback] = wrapWithCurrentZone(prototype[callback], source);
                    }
                }
                else if (prototype[callback]) {
                    prototype[callback] = wrapWithCurrentZone(prototype[callback], source);
                }
            });
        }
        return nativeDelegate.call(target, name, opts, options);
    };
    attachOriginToPatched(target[method], nativeDelegate);
}
326973
function ( target, callback ) {
            if ( typeof Array.prototype.forEach === 'function' ) {
                this.forEach = function ( target, callback ) {
                    if ( this.is(target) ) {
                        target.forEach( callback );
                    } else {
                        throw new Error('[ixBand] "forEach()" ' + MSG_NOT_ARRAY);
                    }
                };
            } else {
                this.forEach = function ( target, callback ) {
                    if ( this.is(target) ) {
                        var tArray = target,
                            aryNum = tArray.length, i;
    
                        for ( i = 0; i < aryNum; ++i ) {
                            callback.call( this , tArray[i], i, tArray );
                        }
                    } else {
                        throw new Error('[ixBand] "forEach()" ' + MSG_NOT_ARRAY);
                    }
                };
            }
    
            this.forEach( target, callback );
        }