e
@param  {String} label the label of the async task
@required @param  {Any} gen   the object to yield
@return {Function}       trunked function
460
function e(label, gen) {
  if (!gen) {
    gen = label;
    label = '';
  }

  if (!enabled) {
    return gen;
  }

  var hackErr = new Error('hack');
  hackErr.label = label;

  return function *() {
    try {
      return yield gen;
    } catch(err) {
      throw buildError(err, hackErr);
    }
  };
}
1367755
private void visitFunction(Node n) {
    if (NodeUtil.isEs6Constructor(n)) {
      return; // These will be checked via the CLASS node.
    }

    FunctionType functionType = JSType.toMaybeFunctionType(n.getJSType());
    if (functionType.isConstructor()) {
      checkConstructor(n, functionType);
    } else if (functionType.isInterface()) {
      checkInterface(n, functionType);
    } else if (n.isAsyncGeneratorFunction()) {
      // An async generator function must return a AsyncGenerator or supertype of AsyncGenerator
      JSType returnType = functionType.getReturnType();
      validator.expectAsyncGeneratorSupertype(
          n,
          returnType,
          "An async generator function must return a (supertype of) AsyncGenerator");
    } else if (n.isGeneratorFunction()) {
      // A generator function must return a Generator or supertype of Generator
      JSType returnType = functionType.getReturnType();
      validator.expectGeneratorSupertype(
          n, returnType, "A generator function must return a (supertype of) Generator");

    } else if (n.isAsyncFunction()) {
      // An async function must return a Promise or supertype of Promise
      JSType returnType = functionType.getReturnType();
      validator.expectValidAsyncReturnType(n, returnType);
    }
  }
1034247
function () {
                return __awaiter(this, void 0, void 0, function () {
                    var _this = this;
                    return __generator(this, function (_a) {
                        switch (_a.label) {
                            case 0: return [4 /*yield*/, this.applyFilter(false)];
                            case 1:
                                _a.sent();
                                if (this.options.maxImageDimensions) {
                                    this.resize(this.editedImage)
                                        .then(function (resizeResult) {
                                        resizeResult.toBlob(function (blob) {
                                            _this.editResult.emit(blob);
                                            _this.processing.emit(false);
                                        }, _this.originalImage.type);
                                    });
                                }
                                else {
                                    this.editedImage.toBlob(function (blob) {
                                        _this.editResult.emit(blob);
                                        _this.processing.emit(false);
                                    }, this.originalImage.type);
                                }
                                return [2 /*return*/];
                        }
                    });
                });
            }
1143310
function FCGeneralNodeView() {
        type.NodeView.apply(this, arguments);

        /** @member {boolean} */
        this.wordWrap = true;

        /** @member {LabelView} */
        this.nameLabel = new type.LabelView();
        this.nameLabel.horizontalAlignment = Graphics.AL_CENTER;
        this.nameLabel.parentStyle = true;
        this.addSubView(this.nameLabel);
    }
1118025
function(label) {
			var forkContext = this.forkContext;

			if (!forkContext.reachable) {
				return;
			}

			var context = getContinueContext(this, label);

			/* istanbul ignore else: foolproof (syntax error) */
			if (context) {
				if (context.continueDestSegments) {
					makeLooped(this, forkContext.head, context.continueDestSegments);

					// If the context is a for-in/of loop, this effects a break also.
					if (context.type === "ForInStatement" ||
						context.type === "ForOfStatement"
					) {
						context.brokenForkContext.add(forkContext.head);
					}
				} else {
					context.continueForkContext.add(forkContext.head);
				}
			}
			forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
		}
615449
public static Label makeActionLabel (Label label, ClickHandler onClick)
    {
        return makeActionable(label, onClick, null);
    }
971233
function generate (generatorName, name, flags) {
  let generator

  switch (generatorName) {
    case 'app':
      generator = new generators.App(name)
      break
    case 'controller':
      generator = new generators.Controller(name, flags)
      break
    case 'model':
      generator = new generators.Model(name, flags)
      break
    case 'view':
      console.log(`generating view ${name} ...`)
      console.log('NotImplemented. View generation not yet available')
      break
    case 'migration':
      generator = new generators.Migration(name, flags)
      break
    case 'scaffold':
      console.log(`generating scaffold ${name} ...`)
      console.log('NotImplemented. Scaffold generation not yet available')
      break
    case 'user':
      console.log(`generating user ${name} ...`)
      console.log('NotImplemented. User generation not yet available')
      break
    default:
      if (!name) {
        return generate('app', generatorName)
      }
  }

  if (!generator) {
    return cli.showHelp(0)
  }

  return generator.run()
}
159900
private void visitYield(NodeTraversal t, Node n) {
    JSType jsType = getJSType(t.getEnclosingFunction());

    JSType declaredYieldType = getNativeType(UNKNOWN_TYPE);
    if (jsType.isFunctionType()) {
      FunctionType functionType = jsType.toMaybeFunctionType();
      JSType returnType = functionType.getReturnType();
      declaredYieldType = JsIterables.getElementType(returnType, typeRegistry);

      if (t.getEnclosingFunction().isAsyncGeneratorFunction()) {
        // Can yield x|IThenable<x> in an AsyncGenerator<x>, no await needed. Note that we must
        // first wrap the type in IThenable as createAsyncReturnableType will map a non-IThenable to
        // `?`.
        declaredYieldType =
            Promises.createAsyncReturnableType(
                typeRegistry, Promises.wrapInIThenable(typeRegistry, declaredYieldType));
      }
    }

    // fetching the yielded value's type
    Node valueNode = n.getFirstChild();
    JSType actualYieldType;
    if (valueNode == null) {
      actualYieldType = getNativeType(VOID_TYPE);
      valueNode = n;
    } else {
      actualYieldType = getJSType(valueNode);
    }

    if (n.isYieldAll()) {
      if (t.getEnclosingFunction().isAsyncGeneratorFunction()) {
        Optional<JSType> maybeActualYieldType =
            validator.expectAutoboxesToIterableOrAsyncIterable(
                n, actualYieldType, "Expression yield* expects an iterable or async iterable");
        if (!maybeActualYieldType.isPresent()) {
          // don't do any further typechecking of the yield* type.
          return;
        }
        actualYieldType = maybeActualYieldType.get();
      } else {
        if (!validator.expectAutoboxesToIterable(
            n, actualYieldType, "Expression yield* expects an iterable")) {
          // don't do any further typechecking of the yield* type.
          return;
        }
        actualYieldType =
            actualYieldType.autobox().getInstantiatedTypeArgument(getNativeType(ITERABLE_TYPE));
      }
    }

    // verifying
    validator.expectCanAssignTo(
        valueNode,
        actualYieldType,
        declaredYieldType,
        "Yielded type does not match declared return type.");
  }
1118504
function fail (label, messages) {
  messages.showAnyWarnings('loading')
  messages.showErrors('loading')

  const oops = new Error(messages.errors.join('\n'))
  oops.errors = messages.errors
  throw oops
}
424122
function(widget, label) {

		if (Lava.schema.DEBUG && !label) Lava.t();

		// Targets are different from view locators, there must be no hardcoded '@widget' label, like in views
		// ('@widget' label may be very harmful in this case. Use widget names instead!)

		if (label == 'root') {

			while (widget.getParentWidget()) {

				widget = widget.getParentWidget();

			}

		} else {

			while (widget && widget.label != label) {

				widget = widget.getParentWidget();

			}

		}

		return widget;

	}
374751
private Label createLabel(String label) {
        Pane pane = new Pane();
        root.addChild(pane);
        Label lbl = new Label();
        lbl.setName(label);
        pane.addChild(lbl);
        adjustPanes();
        return lbl;
    }
1049616
public static Label buildLabel(final String label) {
        return addLabel(Label.newBuilder(), Locale.getDefault(), label).build();
    }
159918
function (tpl) {
            var root = this.parse(tpl);
            variableId = 0;
            return gen.genFunction(root.statements, true);
        }
359390
async function generate(options = {}) {
  options = Object.assign(DEFAULT_OPTIONS, options)

  // Log start
  let msg = `Generating font kit from ${ options.paths.length } SVG icons`.yellow
  log(options, msg)

  // Run validation over options
  await validateOptions(options)

  if (options.codepoints) {
    options.codepointsMap = await getCodepointsMap(options.codepoints)
  }

  // Run font generation
  const config = getGeneratorConfig(options)
  const generatorResult = await fontGenerator(config)

  // Clean up after generator
  await deleteUnspecifiedTypes(options)

  // If specified, generate JSON map
  if (options.json) {
    await generateJson(options, generatorResult)
  }

  // Log generated files
  logReport(options)
}
303805
def _convert_label(label):
    
    style = qt_font_to_style(label.get("font"), label.get("color"))
    return {
        "text": html.escape(label["text"]),
        "rotation": 0,
        "style": style,
        "x": int(label["x"]),
        "y": int(label["y"])
    }
612070
private static <I, D> void markAndPropagate(AbstractBaseDTNode<I, D> node, D label) {
        AbstractBaseDTNode<I, D> curr = node;

        while (curr != null && curr.getSplitData() != null) {
            if (!curr.getSplitData().mark(label)) {
                return;
            }
            curr = curr.getParent();
        }
    }
1013419
public Expression labelStart(final Label label) {
    return new Expression(resultType(), features) {
      @Override
      protected void doGen(CodeBuilder adapter) {
        adapter.mark(label);
        Expression.this.gen(adapter);
      }
    };
  }