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;
    },

 compile(node: ts.ClassDeclaration, analysis: R3DirectiveMetadata, pool: ConstantPool):
     CompileResult {
   const res = compileDirectiveFromMetadata(analysis, pool, makeBindingParser());
   return {
     name: 'ngDirectiveDef',
     initializer: res.expression,
     statements: res.statements,
     type: res.type,
   };
 }

 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;
 },

 compile(node: ts.ClassDeclaration, analysis: DirectiveHandlerData, pool: ConstantPool):
     CompileResult {
   const res = compileDirectiveFromMetadata(analysis.meta, pool, makeBindingParser());
   const statements = res.statements;
   if (analysis.metadataStmt !== null) {
     statements.push(analysis.metadataStmt);
   }
   return {
     name: 'ngDirectiveDef',
     initializer: res.expression,
     statements: statements,
     type: res.type,
   };
 }

  compile(node: ts.ClassDeclaration, analysis: R3ComponentMetadata): CompileResult {
    const pool = new ConstantPool();

    // Check whether this component was registered with an NgModule. If so, it should be compiled
    // under that module's compilation scope.
    const scope = this.scopeRegistry.lookupCompilationScope(node);
    if (scope !== null) {
      // Replace the empty components and directives from the analyze() step with a fully expanded
      // scope. This is possible now because during compile() the whole compilation unit has been
      // fully analyzed.
      analysis = {...analysis, ...scope};
    }

    const res = compileComponentFromMetadata(analysis, pool, makeBindingParser());
    return {
      field: 'ngComponentDef',
      initializer: res.expression,
      statements: pool.statements,
      type: res.type,
    };
  }

    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;
    },