TypeScript compiler.jitExpression函数代码示例

    get: () => {
      if (def === null) {
        // Check whether the injectable metadata includes a provider specification.
        const hasAProvider = isUseClassProvider(meta) || isUseFactoryProvider(meta) ||
            isUseValueProvider(meta) || isUseExistingProvider(meta);

        let deps: R3DependencyMetadata[]|undefined = undefined;
        if (!hasAProvider || (isUseClassProvider(meta) && type === meta.useClass)) {
          deps = reflectDependencies(type);
        } else if (isUseClassProvider(meta)) {
          deps = meta.deps && convertDependencies(meta.deps);
        } else if (isUseFactoryProvider(meta)) {
          deps = meta.deps && convertDependencies(meta.deps) || [];
        }

        // Decide which flavor of factory to generate, based on the provider specified.
        // Only one of the use* fields should be set.
        let useClass: Expression|undefined = undefined;
        let useFactory: Expression|undefined = undefined;
        let useValue: Expression|undefined = undefined;
        let useExisting: Expression|undefined = undefined;

        if (!hasAProvider) {
          // In the case the user specifies a type provider, treat it as {provide: X, useClass: X}.
          // The deps will have been reflected above, causing the factory to create the class by
          // calling
          // its constructor with injected deps.
          useClass = new WrappedNodeExpr(type);
        } else if (isUseClassProvider(meta)) {
          // The user explicitly specified useClass, and may or may not have provided deps.
          useClass = new WrappedNodeExpr(meta.useClass);
        } else if (isUseValueProvider(meta)) {
          // The user explicitly specified useValue.
          useValue = new WrappedNodeExpr(meta.useValue);
        } else if (isUseFactoryProvider(meta)) {
          // The user explicitly specified useFactory.
          useFactory = new WrappedNodeExpr(meta.useFactory);
        } else if (isUseExistingProvider(meta)) {
          // The user explicitly specified useExisting.
          useExisting = new WrappedNodeExpr(meta.useExisting);
        } else {
          // Can't happen - either hasAProvider will be false, or one of the providers will be set.
          throw new Error(`Unreachable state.`);
        }

        const {expression} = compileR3Injectable({
          name: type.name,
          type: new WrappedNodeExpr(type),
          providedIn: computeProvidedIn(meta.providedIn),
          useClass,
          useFactory,
          useValue,
          useExisting,
          deps,
        });

        def = jitExpression(expression, angularCoreEnv, `ng://${type.name}/ngInjectableDef.js`);
      }
      return def;
    },

    get: () => {
      if (ngComponentDef === null) {
        if (componentNeedsResolution(metadata)) {
          const error = [`Component '${stringify(type)}' is not resolved:`];
          if (metadata.templateUrl) {
            error.push(` - templateUrl: ${stringify(metadata.templateUrl)}`);
          }
          if (metadata.styleUrls && metadata.styleUrls.length) {
            error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);
          }
          error.push(`Did you run and wait for 'resolveComponentResources()'?`);
          throw new Error(error.join('\n'));
        }
        // The ConstantPool is a requirement of the JIT'er.
        const constantPool = new ConstantPool();

        // Parse the template and check for errors.
        const template = parseTemplate(
            metadata.template !, `ng://${stringify(type)}/template.html`, {
              preserveWhitespaces: metadata.preserveWhitespaces || false,
            },
            '');
        if (template.errors !== undefined) {
          const errors = template.errors.map(err => err.toString()).join(', ');
          throw new Error(
              `Errors during JIT compilation of template for ${stringify(type)}: ${errors}`);
        }

        // Compile the component metadata, including template, into an expression.
        // TODO(alxhub): implement inputs, outputs, queries, etc.
        const res = compileR3Component(
            {
              ...directiveMetadata(type, metadata),
              template,
              directives: new Map(),
              pipes: new Map(),
              viewQueries: [],
              wrapDirectivesInClosure: false,
              styles: metadata.styles || [],
              encapsulation: metadata.encapsulation || ViewEncapsulation.Emulated,
              animations: metadata.animations || null
            },
            constantPool, makeBindingParser());
        const preStatements = [...constantPool.statements, ...res.statements];

        ngComponentDef = jitExpression(
            res.expression, angularCoreEnv, `ng://${type.name}/ngComponentDef.js`, preStatements);

        // If component compilation is async, then the @NgModule annotation which declares the
        // component may execute and set an ngSelectorScope property on the component type. This
        // allows the component to patch itself with directiveDefs from the module after it
        // finishes compiling.
        if (hasSelectorScope(type)) {
          const scopes = transitiveScopesFor(type.ngSelectorScope);
          patchComponentDefWithScope(ngComponentDef, scopes);
        }
      }
      return ngComponentDef;
    },

 get: () => {
   if (def === null) {
     const constantPool = new ConstantPool();
     const sourceMapUrl = `ng://${type && type.name}/ngDirectiveDef.js`;
     const res = compileR3Directive(
         directiveMetadata(type, directive), constantPool, makeBindingParser());
     def = jitExpression(res.expression, angularCoreEnv, sourceMapUrl, constantPool);
   }
   return def;
 },

    get: () => {
      if (ngPipeDef === null) {
        const sourceMapUrl = `ng://${stringify(type)}/ngPipeDef.js`;

        const name = type.name;
        const res = compilePipeFromMetadata({
          name,
          type: new WrappedNodeExpr(type),
          deps: reflectDependencies(type),
          pipeName: meta.name,
          pure: meta.pure !== undefined ? meta.pure : true,
        });

        ngPipeDef = jitExpression(res.expression, angularCoreEnv, sourceMapUrl, res.statements);
      }
      return ngPipeDef;
    },

 get: () => {
   if (def === null) {
     const meta: R3NgModuleMetadata = {
       type: wrap(type),
       bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY).map(wrap),
       declarations: declarations.map(wrap),
       imports:
           flatten(ngModule.imports || EMPTY_ARRAY).map(expandModuleWithProviders).map(wrap),
       exports:
           flatten(ngModule.exports || EMPTY_ARRAY).map(expandModuleWithProviders).map(wrap),
       emitInline: true,
     };
     const res = compileR3NgModule(meta);
     def = jitExpression(res.expression, angularCoreEnv, `ng://${type.name}/ngModuleDef.js`);
   }
   return def;
 },

 get: () => {
   if (ngInjectorDef === null) {
     const meta: R3InjectorMetadata = {
       name: type.name,
       type: wrap(type),
       deps: reflectDependencies(type),
       providers: new WrappedNodeExpr(ngModule.providers || EMPTY_ARRAY),
       imports: new WrappedNodeExpr([
         ngModule.imports || EMPTY_ARRAY,
         ngModule.exports || EMPTY_ARRAY,
       ]),
     };
     const res = compileInjector(meta);
     ngInjectorDef =
         jitExpression(res.expression, angularCoreEnv, `ng://${type.name}/ngInjectorDef.js`);
   }
   return ngInjectorDef;
 },

    get: () => {
      if (def === null) {
        // The ConstantPool is a requirement of the JIT'er.
        const constantPool = new ConstantPool();

        // Parse the template and check for errors.
        const template = parseTemplate(templateStr, `ng://${type.name}/template.html`, {
          preserveWhitespaces: metadata.preserveWhitespaces || false,
        });
        if (template.errors !== undefined) {
          const errors = template.errors.map(err => err.toString()).join(', ');
          throw new Error(`Errors during JIT compilation of template for ${type.name}: ${errors}`);
        }

        // Compile the component metadata, including template, into an expression.
        // TODO(alxhub): implement inputs, outputs, queries, etc.
        const res = compileR3Component(
            {
              ...directiveMetadata(type, metadata),
              template,
              directives: new Map(),
              pipes: new Map(),
              viewQueries: [],
            },
            constantPool, makeBindingParser());

        def = jitExpression(
            res.expression, angularCoreEnv, `ng://${type.name}/ngComponentDef.js`, constantPool);

        // If component compilation is async, then the @NgModule annotation which declares the
        // component may execute and set an ngSelectorScope property on the component type. This
        // allows the component to patch itself with directiveDefs from the module after it finishes
        // compiling.
        if (hasSelectorScope(type)) {
          patchComponentDefWithScope(def, type.ngSelectorScope);
        }
      }
      return def;
    },