Function compileFunctions

server/functions/framework/catalog.go:218–256

compileFunctions creates a CompiledFunction for each overload of each function in the catalog.

()

// compileFunctions creates a CompiledFunction for each overload of each function in the catalog.
func compileFunctions() {
	for funcName, overloads := range Catalog {
		compileNonOperatorFunction(funcName, overloads)
	}

	// Build the overload for all unary and binary functions based on their operator. This will be used for fallback if
	// an exact match is not found. Compiled functions (which wrap the overload deducer) handle upcasting and other
	// special rules, so it's far more efficient to reuse it for operators. Operators are also a special case since they
	// all have different names, while standard overload deducers work on a function-name basis.
	for signature, functionOverload := range unaryFunctions {
		overloads, ok := unaryOperatorOverloads[signature.Operator]
		if !ok {
			overloads = NewOverloads()
			unaryOperatorOverloads[signature.Operator] = overloads
		}
		if err := overloads.Add(functionOverload); err != nil {
			panic(err)
		}
	}

	for signature, functionOverload := range binaryFunctions {
		overloads, ok := binaryOperatorOverloads[signature.Operator]
		if !ok {
			overloads = NewOverloads()
			binaryOperatorOverloads[signature.Operator] = overloads
		}
		if err := overloads.Add(functionOverload); err != nil {
			panic(err)
		}
	}

	// Add all permutations for the unary and binary operators
	for operator, overload := range unaryOperatorOverloads {
		unaryOperatorPermutations[operator] = overload.overloadsForParams(1)
	}
	for operator, overload := range binaryOperatorOverloads {
		binaryOperatorPermutations[operator] = overload.overloadsForParams(2)
	}
}

func compileAggs() {
	for funcName, overloads := range AggregateCatalog {