Method compile

lib/base-compiler.ts:3211–3334

(
        source: string,
        options: string[],
        backendOptions: Record<string, any>,
        filters: ParseFiltersAndOutputOptions,
        bypassCache: BypassCache,
        tools: ActiveTool[],
        executeParameters: ExecutionParams,
        libraries: SelectedLibraryVersion[],
        files: FiledataPair[],
    )

    }

    async compile(
        source: string,
        options: string[],
        backendOptions: Record<string, any>,
        filters: ParseFiltersAndOutputOptions,
        bypassCache: BypassCache,
        tools: ActiveTool[],
        executeParameters: ExecutionParams,
        libraries: SelectedLibraryVersion[],
        files: FiledataPair[],
    ) {
        const optionsError = this.checkOptions(options);
        if (optionsError) throw optionsError;

        const libsAndOptions = {libraries, options};
        if (this.tryAutodetectLibraries(libsAndOptions)) {
            libraries = libsAndOptions.libraries;
            options = libsAndOptions.options;
        }

        this.fixFiltersBeforeCacheKey(filters, options, files);

        const executeOptions: ExecutableExecutionOptions = {
            args: executeParameters.args || [],
            stdin: executeParameters.stdin || '',
            ldPath: [],
            env: {},
            runtimeTools: executeParameters.runtimeTools || [],
        };

        const key = this.getCacheKey(source, options, backendOptions, filters, tools, libraries, files);

        const doExecute = filters.execute;
        filters = Object.assign({}, filters);
        filters.execute = false;

        if (!bypassCompilationCache(bypassCache)) {
            const cacheRetrieveTimeStart = process.hrtime.bigint();
            // TODO: We should be able to eliminate this any cast. `key` should be cacheable (if it's not that's a big
            // problem) Because key contains a CompilerInfo which contains a function member it can't be assigned to a
            // CacheableValue.
            const result = await this.env.cacheGet(key as any);
            if (result) {
                const cacheRetrieveTimeEnd = process.hrtime.bigint();
                result.retreivedFromCacheTime = utils.deltaTimeNanoToMili(cacheRetrieveTimeStart, cacheRetrieveTimeEnd);
                result.retreivedFromCache = true;
                result.s3Key = BaseCache.hash(key);
                if (doExecute) {
                    const queueTime = performance.now();
                    result.execResult = await this.env.enqueue(
                        async () => {
                            const start = performance.now();
                            executionQueueTimeHistogram.observe((start - queueTime) / 1000);
                            const res = await this.handleExecution(key, executeOptions, bypassCache);
                            executionTimeHistogram.observe((performance.now() - start) / 1000);
                            return res;
                        },
                        {abandonIfStale: true},