import { AccessSpecifier } from "../../ast/ast_declarations";
import { CPPConstruct } from "../constructs/CPPConstruct";
import { RuntimeExpression } from "../constructs/expressions/RuntimeExpression";
import { AtomicType, CompleteClassType, CompleteObjectType, ExpressionType } from "./types";
import { ClassEntity, CompleteClassEntity, FunctionEntity, LocalObjectEntity, LocalReferenceEntity, LocalVariableEntity } from "./entities";
import { Program, TranslationUnit } from "./Program";
import { BlockScope, ClassScope, Scope } from "./scopes";
export interface ConstructDescription {
    name?: string;
    message: string;
}
export interface ConstructExplanation {
    message: string;
}
export interface ProgramContext {
    readonly program: Program;
    readonly translationUnit?: TranslationUnit;
    readonly implicit?: boolean;
    readonly libraryId?: number;
    readonly libraryUnsupported?: boolean;
}
export declare function createImplicitContext<ContextType extends ProgramContext>(context: ContextType): ContextType;
export interface TranslationUnitContext extends ProgramContext {
    readonly translationUnit: TranslationUnit;
    readonly contextualScope: Scope;
    readonly containingClass?: ClassEntity;
    readonly isLibrary: boolean;
}
export declare function createTranslationUnitContext(parentContext: ProgramContext, translationUnit: TranslationUnit, contextualScope: Scope): TranslationUnitContext;
export declare function createLibraryContext(parentContext: TranslationUnitContext): TranslationUnitContext;
export interface ExpressionContext extends TranslationUnitContext {
    readonly contextualParameterTypes?: readonly (ExpressionType | undefined)[];
    readonly contextualReceiverType?: CompleteClassType;
}
export declare function createExpressionContextWithParameterTypes(parentContext: TranslationUnitContext, contextualParameterTypes: readonly (ExpressionType | undefined)[]): ExpressionContext;
export declare function createExpressionContextWithReceiverType(parentContext: TranslationUnitContext, contextualReceiverType: CompleteClassType): ExpressionContext;
export interface FunctionContext extends TranslationUnitContext {
    readonly containingFunction: FunctionEntity;
    readonly functionLocals: ContextualLocals;
    readonly contextualReceiverType?: CompleteClassType;
}
export declare function isFunctionContext(context: TranslationUnitContext): context is FunctionContext;
export declare function createFunctionContext(parentContext: TranslationUnitContext, containingFunction: FunctionEntity, contextualReceiverType: CompleteClassType): MemberFunctionContext;
export declare function createFunctionContext(parentContext: TranslationUnitContext, containingFunction: FunctionEntity, contextualReceiverType?: CompleteClassType): FunctionContext;
export declare function isMemberFunctionContext(context: TranslationUnitContext): context is MemberFunctionContext;
export interface MemberFunctionContext extends FunctionContext {
    readonly contextualReceiverType: CompleteClassType;
}
export interface BlockContext extends FunctionContext {
    readonly contextualScope: BlockScope;
    readonly blockLocals: ContextualLocals;
    readonly withinLoop?: true;
}
export declare function createBlockContext(parentContext: FunctionContext, sharedScope?: BlockScope): BlockContext;
export declare function isMemberBlockContext(context: BlockContext): context is MemberBlockContext;
export interface MemberBlockContext extends BlockContext {
    readonly contextualReceiverType: CompleteClassType;
}
export declare function isBlockContext(context: TranslationUnitContext): context is BlockContext;
export declare function createLoopContext<C extends BlockContext>(parentContext: C): C & {
    withinLoop: boolean;
};
export declare function isClassContext(context: TranslationUnitContext): context is ClassContext;
export interface ClassContext extends TranslationUnitContext {
    readonly contextualScope: ClassScope;
    readonly baseClass?: CompleteClassEntity;
    readonly containingClass: ClassEntity;
    readonly templateType?: AtomicType;
}
export declare function createClassContext(parentContext: TranslationUnitContext, classEntity: ClassEntity, baseClass?: CompleteClassEntity, templateType?: AtomicType): ClassContext;
export declare function isMemberSpecificationContext(context: TranslationUnitContext): context is MemberSpecificationContext;
export declare function createOutOfLineFunctionDefinitionContext(declarationContext: MemberSpecificationContext, newParent: TranslationUnitContext): MemberSpecificationContext & {
    contextualScope: any;
    translationUnit: TranslationUnit;
};
export interface MemberSpecificationContext extends ClassContext {
    readonly accessLevel: AccessSpecifier;
}
export declare function createMemberSpecificationContext(classContext: ClassContext, accessLevel: AccessSpecifier): MemberSpecificationContext;
export declare type SemanticContext = {};
export declare function areAllSemanticallyEquivalent(constructs: readonly CPPConstruct[], others: readonly CPPConstruct[], equivalenceContext: SemanticContext): boolean;
export declare function isAnythingConstruct(construct: CPPConstruct | undefined): boolean;
export declare function areSemanticallyEquivalent(construct: CPPConstruct | undefined, other: CPPConstruct | undefined, equivalenceContext: SemanticContext): boolean;
export declare class ContextualLocals {
    readonly localVariables: readonly LocalVariableEntity[];
    readonly localObjects: readonly LocalObjectEntity[];
    readonly localReferences: readonly LocalReferenceEntity[];
    readonly localVariablesByEntityId: {
        [index: number]: LocalVariableEntity;
    };
    registerLocalVariable(local: LocalVariableEntity): void;
}
export declare function lookupTypeInContext(typeName: string): (context: ExpressionContext) => CompleteClassType | import("./types").IncompleteClassType;
export declare function getLocal<T extends CompleteObjectType>(rt: RuntimeExpression, name: string): import("../runtime/objects").CPPObject<T>;