import { FunctionDefinitionASTNode } from "../../../../ast/ast_declarations";
import { FunctionContext, SemanticContext, TranslationUnitContext } from "../../../compilation/contexts";
import { RuntimeFunction } from "../../../compilation/functions";
import { CPPObject } from "../../../runtime/objects";
import { AnalyticConstruct } from "../../../../analysis/predicates";
import { Block, CompiledBlock } from "../../statements/Block";
import { CompleteClassType, CompleteReturnType, FunctionType } from "../../../compilation/types";
import { SuccessfullyCompiled } from "../../CPPConstruct";
import { BasicCPPConstruct } from "../../BasicCPPConstruct";
import { InvalidConstruct } from "../../InvalidConstruct";
import { RuntimeFunctionCall } from "../../FunctionCall";
import { CompiledCtorInitializer, CtorInitializer } from "../../initializers/CtorInitializer";
import { CompiledObjectDeallocator, ObjectDeallocator } from "../../ObjectDeallocator";
import { CompiledFunctionDeclaration, FunctionDeclaration, TypedFunctionDeclaration } from "./FunctionDeclaration";
import { CompiledParameterDeclaration, ParameterDeclaration } from "./ParameterDeclaration";
export declare class FunctionDefinition extends BasicCPPConstruct<FunctionContext, FunctionDefinitionASTNode> {
    readonly construct_type = "function_definition";
    readonly kind = "FunctionDefinition";
    readonly declaration: FunctionDeclaration;
    readonly name: string;
    readonly type: FunctionType;
    readonly parameters: readonly ParameterDeclaration[];
    readonly ctorInitializer?: CtorInitializer | InvalidConstruct;
    readonly body: Block;
    isOutOfLineMemberFunctionDefinition: boolean;
    /**
     * Only defined for destructors. A deallocator for the member
     * variables of the receiver that will run after the destructor itself.
     */
    readonly memberDeallocator?: ObjectDeallocator;
    static createFromAST(ast: FunctionDefinitionASTNode, context: TranslationUnitContext, declaration: FunctionDeclaration): FunctionDefinition;
    static createFromAST(ast: FunctionDefinitionASTNode, context: TranslationUnitContext, declaration?: FunctionDeclaration): FunctionDefinition | InvalidConstruct;
    constructor(context: FunctionContext, ast: FunctionDefinitionASTNode, declaration: FunctionDeclaration, parameters: readonly ParameterDeclaration[], ctorInitializer: CtorInitializer | InvalidConstruct | undefined, body: Block, outOfLineMemberFunction: boolean);
    createRuntimeFunction<T extends FunctionType<CompleteReturnType>>(this: CompiledFunctionDefinition<T>, parent: RuntimeFunctionCall, receiver?: CPPObject<CompleteClassType>): RuntimeFunction<T>;
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, equivalenceContext: SemanticContext): boolean;
}
/**
 * Attempts to create a `FunctionDeclaration` from the given function definition AST. Note this may
 * return an InvalidConstrucct if the given AST was malformed such that the declarator didn't actually specify
 * a function (e.g. missing parentheses). This is unfortunately allowed by the language grammar, so
 * we have to account for it.
 * @param ast
 * @param context
 */
export declare function createFunctionDeclarationFromDefinitionAST(ast: FunctionDefinitionASTNode, context: TranslationUnitContext): FunctionDeclaration | InvalidConstruct;
export interface TypedFunctionDefinition<T extends FunctionType> extends FunctionDefinition {
    readonly type: T;
    readonly declaration: TypedFunctionDeclaration<T>;
}
export interface CompiledFunctionDefinition<T extends FunctionType = FunctionType> extends TypedFunctionDefinition<T>, SuccessfullyCompiled {
    readonly declaration: CompiledFunctionDeclaration<T>;
    readonly name: string;
    readonly parameters: readonly CompiledParameterDeclaration[];
    readonly ctorInitializer?: CompiledCtorInitializer;
    readonly body: CompiledBlock;
    readonly memberDeallocator?: CompiledObjectDeallocator;
}