See `Compiler.compile`
542281
def compile(self, # type: ignore
                manager_container,
                container: 'Container', # type: ignore
                verbose: bool = False
                ) -> CompilationOutcome:
        
        return self.__compile(manager_container,
                              container,
                              self.__command,
                              verbose)
402527
def compile(source, options = {})
      source  = prepare_source(source)
      options = prepare_options(options)
      snippet = compilation_snippet \
        method:    "compile#{ "Client" if options[:client] }",
        arguments: [source, options],
        locals:    options.fetch(:locals, {}),
        options:   options
      result  = @execjs.eval(snippet)
      process_result(source, result, options)
    rescue ExecJS::ProgramError => e
      raise engine::CompilationError, e.message
    end
1275183
function mixin(compiler) {
  compiler._comment = compiler.comment;
  compiler.map = new SourceMap();
  compiler.position = { line: 1, column: 1 };
  compiler.files = {};
  for (var k in exports) compiler[k] = exports[k];
}
1160582
function buildToStdout(compileOptions) {
  return compile(compileOptions).then(result => process.stdout.write(result.css))
}
445590
async function compile() {
  let codes;
  const paths = await glob(['./es/**/*.less', './lib/**/*.less'], { absolute: true });

  codes = await Promise.all(paths.map(path => fs.readFile(path, 'utf-8')));
  codes = await compileLess(codes, paths);
  codes = await compilePostcss(codes, paths);
  codes = await compileCsso(codes);

  await dest(codes, paths);
}
135049
function Compiler(locales, formats, pluralFn) {
  this.locales = locales;
  this.formats = formats;
  this.pluralFn = pluralFn;
}
1070466
function compile(config) {
  let compiler;
  try {
    compiler = webpack(config);
  } catch (e) {
    printErrors('Failed to compile.', [e]);
    process.exit(1);
  }
  return compiler;
}
1145346
function webpackGetCodeOnDone (compiler, done) {
	if (!(compiler instanceof Compiler)) {
		throw new Error(`Expected compiler to be an instance of 'Compiler'`)
	}

	const outputFs = compiler.outputFileSystem
	const outputPath = compiler.outputPath

	installSourceMapSupport(outputFs)

	let compiledCode
	let error = false

	compiler.plugin('done', stats => {
		error = false
		// Server compilation errors need to be propagated to the client.
		if (stats.compilation.errors.length) {
			error = stats.compilation.errors[0]
			return
		}
		const filename = getFilename(stats, outputPath, 'main')
		const buffer = outputFs.readFileSync(filename)

		try {
			compiledCode = getCompiled(filename, buffer)
		} catch (ex) {
			error = ex
		}

		if (compiledCode) {
			done(compiledCode)
		} else {
			throw new Error(
				`webpack-get-code-on-done: Compiled code is 'undefined'. Please check latest changes that may produced this error. ${error}`
			)
		}
	})
}
1328199
function compilePackage(p) {
      compileForType(p);
      p.path = getPackagePath(p);
      p.compiledBody = compact([
        STRICT,
        getRequires(p),
        getDirectRequires(p),
        getAssigns(p),
        p.body,
        getPostAssigns(p),
        getExports(p)
      ]).join('\n\n');
    }
1225294
function bundleCompilers(compilers, opts) {
    if (!opts) { opts = {}; }

    var transforms = [].concat(opts.pipeTo || []);
    var s = stream.PassThrough({ objectMode: !!opts.objectMode });

    Rx.Node.writeToStream(
        compilers.flatMap(function (res) {
            var bundle = res.compiler.bundle(R.omit(["objectMode", "pipeTo"], opts));

            return Rx.Node.fromStream(
                R.reduce(function (b, t) {
                    return b.pipe(t(res.name, res.compiler));
                }, bundle, transforms)
            );
        }),
        s
    );

    return s;
}
806855
function compile(config) {
    let compiler;
    try {
        compiler = webpack(config);
    }
    catch (error) {
        console.error('Failed to compile.', error);
        process.exitCode = 1;
    }
    return compiler;
}
626654
def for_compiler(self, compiler, platform):
    """"""
    return (self.linker
            # TODO(#6143): describe why the compiler needs to be first on the PATH!
            .sequence(compiler, exclude_list_fields=['extra_args', 'path_entries'])
            .prepend_field('path_entries', compiler.path_entries)
            .copy(exe_filename=compiler.exe_filename))
818459
def compile(self):
        """"""
        result = TEMPLATE

        for rule in self.rules:
            if rule[2]:
                arrow = '=>'
            else:
                arrow = '->'
            repr_rule = repr(rule[0] + arrow + rule[1])

            result += "algo.add_rule({repr_rule})\n".format(repr_rule=repr_rule)

        result += "for line in stdin:\n"
        result += "    print(algo.execute(''.join(line.split())))"
        return result
1218735
function compiler(parsed, opts) {
  options = opts;
  const compiled = compile(parsed);

  return t.functionDeclaration(c.COMPILED, c.runtimeParams, t.blockStatement([
    t.returnStatement(ConcatStringList(compiled)),
  ]));
}
854072
def _make_compile_argv(self, compile_request):
    """"""

    sources_minus_headers = list(self._iter_sources_minus_headers(compile_request))
    if len(sources_minus_headers) == 0:
      raise self._HeaderOnlyLibrary()

    compiler = compile_request.compiler
    compiler_options = compile_request.compiler_options
    # We are going to execute in the target output, so get absolute paths for everything.
    buildroot = get_buildroot()
    # TODO: add -v to every compiler and linker invocation!
    argv = (
      [compiler.exe_filename] +
      compiler.extra_args +
      # TODO: If we need to produce static libs, don't add -fPIC! (could use Variants -- see #5788).
      ['-c', '-fPIC'] +
      compiler_options +
      [
        '-I{}'.format(os.path.join(buildroot, inc_dir))
        for inc_dir in compile_request.include_dirs
      ] +
      [os.path.join(buildroot, src) for src in sources_minus_headers])

    self.context.log.info("selected compiler exe name: '{}'".format(compiler.exe_filename))
    self.context.log.debug("compile argv: {}".format(argv))

    return argv
496585
def compile(self):
        """"""
        return "{attribute}{sep}{value}".format(
            attribute=self.attribute,
            sep=self.sep,
            value=_quoted(self.value)
        )
1199659
function basicPrecompiled(){
  gulp.src("./examples/basic-precompiled/example.jsx")
    .pipe(browserify())
    .pipe(rename("compiled.js"))
    .pipe(gulp.dest("./examples/basic-precompiled"));

}