static-injector 4.0.1 → 5.0.0-alpha.0

package/transform/compiler/src/output/output_ast.d.ts

@@ -1,512 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ParseSourceSpan } from '../parse_util';
-export declare enum TypeModifier {
-    None = 0,
-    Const = 1
-}
-export declare abstract class Type {
-    modifiers: TypeModifier;
-    constructor(modifiers?: TypeModifier);
-    abstract visitType(visitor: TypeVisitor, context: any): any;
-    hasModifier(modifier: TypeModifier): boolean;
-}
-export declare enum BuiltinTypeName {
-    Dynamic = 0,
-    Bool = 1,
-    String = 2,
-    Int = 3,
-    Number = 4,
-    Function = 5,
-    Inferred = 6,
-    None = 7
-}
-export declare class BuiltinType extends Type {
-    name: BuiltinTypeName;
-    constructor(name: BuiltinTypeName, modifiers?: TypeModifier);
-    visitType(visitor: TypeVisitor, context: any): any;
-}
-export declare class ExpressionType extends Type {
-    value: Expression;
-    typeParams: Type[] | null;
-    constructor(value: Expression, modifiers?: TypeModifier, typeParams?: Type[] | null);
-    visitType(visitor: TypeVisitor, context: any): any;
-}
-export declare class ArrayType extends Type {
-    of: Type;
-    constructor(of: Type, modifiers?: TypeModifier);
-    visitType(visitor: TypeVisitor, context: any): any;
-}
-export declare class MapType extends Type {
-    valueType: Type | null;
-    constructor(valueType: Type | null | undefined, modifiers?: TypeModifier);
-    visitType(visitor: TypeVisitor, context: any): any;
-}
-export declare class TransplantedType<T> extends Type {
-    readonly type: T;
-    constructor(type: T, modifiers?: TypeModifier);
-    visitType(visitor: TypeVisitor, context: any): any;
-}
-export declare const DYNAMIC_TYPE: BuiltinType;
-export declare const INFERRED_TYPE: BuiltinType;
-export declare const BOOL_TYPE: BuiltinType;
-export declare const INT_TYPE: BuiltinType;
-export declare const NUMBER_TYPE: BuiltinType;
-export declare const STRING_TYPE: BuiltinType;
-export declare const FUNCTION_TYPE: BuiltinType;
-export declare const NONE_TYPE: BuiltinType;
-export interface TypeVisitor {
-    visitBuiltinType(type: BuiltinType, context: any): any;
-    visitExpressionType(type: ExpressionType, context: any): any;
-    visitArrayType(type: ArrayType, context: any): any;
-    visitMapType(type: MapType, context: any): any;
-    visitTransplantedType(type: TransplantedType<unknown>, context: any): any;
-}
-export declare enum UnaryOperator {
-    Minus = 0,
-    Plus = 1
-}
-export declare enum BinaryOperator {
-    Equals = 0,
-    NotEquals = 1,
-    Identical = 2,
-    NotIdentical = 3,
-    Minus = 4,
-    Plus = 5,
-    Divide = 6,
-    Multiply = 7,
-    Modulo = 8,
-    And = 9,
-    Or = 10,
-    BitwiseOr = 11,
-    BitwiseAnd = 12,
-    Lower = 13,
-    LowerEquals = 14,
-    Bigger = 15,
-    BiggerEquals = 16,
-    NullishCoalesce = 17
-}
-export declare function nullSafeIsEquivalent<T extends {
-    isEquivalent(other: T): boolean;
-}>(base: T | null, other: T | null): boolean;
-export declare function areAllEquivalent<T extends {
-    isEquivalent(other: T): boolean;
-}>(base: T[], other: T[]): boolean;
-export declare abstract class Expression {
-    type: Type | null;
-    sourceSpan: ParseSourceSpan | null;
-    constructor(type: Type | null | undefined, sourceSpan?: ParseSourceSpan | null);
-    abstract visitExpression(visitor: ExpressionVisitor, context: any): any;
-    /**
-     * Calculates whether this expression produces the same value as the given expression.
-     * Note: We don't check Types nor ParseSourceSpans nor function arguments.
-     */
-    abstract isEquivalent(e: Expression): boolean;
-    /**
-     * Return true if the expression is constant.
-     */
-    abstract isConstant(): boolean;
-    abstract clone(): Expression;
-    prop(name: string, sourceSpan?: ParseSourceSpan | null): ReadPropExpr;
-    key(index: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null): ReadKeyExpr;
-    callFn(params: Expression[], sourceSpan?: ParseSourceSpan | null, pure?: boolean): InvokeFunctionExpr;
-    bitwiseOr(rhs: Expression, sourceSpan?: ParseSourceSpan | null, parens?: boolean): BinaryOperatorExpr;
-    toStmt(): Statement;
-}
-export declare class ReadVarExpr extends Expression {
-    name: string;
-    constructor(name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): ReadVarExpr;
-    set(value: Expression): WriteVarExpr;
-}
-export declare class TypeofExpr extends Expression {
-    expr: Expression;
-    constructor(expr: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    clone(): TypeofExpr;
-}
-export declare class WrappedNodeExpr<T> extends Expression {
-    node: T;
-    constructor(node: T, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): WrappedNodeExpr<T>;
-}
-export declare class WriteVarExpr extends Expression {
-    name: string;
-    value: Expression;
-    constructor(name: string, value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): WriteVarExpr;
-    toDeclStmt(type?: Type | null, modifiers?: StmtModifier): DeclareVarStmt;
-    toConstDecl(): DeclareVarStmt;
-}
-export declare class WriteKeyExpr extends Expression {
-    receiver: Expression;
-    index: Expression;
-    value: Expression;
-    constructor(receiver: Expression, index: Expression, value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): WriteKeyExpr;
-}
-export declare class WritePropExpr extends Expression {
-    receiver: Expression;
-    name: string;
-    value: Expression;
-    constructor(receiver: Expression, name: string, value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): WritePropExpr;
-}
-export declare class InvokeFunctionExpr extends Expression {
-    fn: Expression;
-    args: Expression[];
-    pure: boolean;
-    constructor(fn: Expression, args: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null, pure?: boolean);
-    get receiver(): Expression;
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): InvokeFunctionExpr;
-}
-export declare class InstantiateExpr extends Expression {
-    classExpr: Expression;
-    args: Expression[];
-    constructor(classExpr: Expression, args: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): InstantiateExpr;
-}
-export declare class LiteralExpr extends Expression {
-    value: number | string | boolean | null | undefined;
-    constructor(value: number | string | boolean | null | undefined, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): LiteralExpr;
-}
-export declare class TemplateLiteral {
-    elements: TemplateLiteralElement[];
-    expressions: Expression[];
-    constructor(elements: TemplateLiteralElement[], expressions: Expression[]);
-    clone(): TemplateLiteral;
-}
-export declare class TemplateLiteralElement {
-    text: string;
-    sourceSpan?: ParseSourceSpan | undefined;
-    rawText: string;
-    constructor(text: string, sourceSpan?: ParseSourceSpan | undefined, rawText?: string);
-    clone(): TemplateLiteralElement;
-}
-export declare class LiteralPiece {
-    text: string;
-    sourceSpan: ParseSourceSpan;
-    constructor(text: string, sourceSpan: ParseSourceSpan);
-}
-/**
- * A structure to hold the cooked and raw strings of a template literal element, along with its
- * source-span range.
- */
-export interface CookedRawString {
-    cooked: string;
-    raw: string;
-    range: ParseSourceSpan | null;
-}
-export declare class ExternalExpr extends Expression {
-    value: ExternalReference;
-    typeParams: Type[] | null;
-    constructor(value: ExternalReference, type?: Type | null, typeParams?: Type[] | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): ExternalExpr;
-}
-export declare class ExternalReference {
-    moduleName: string | null;
-    name: string | null;
-    runtime?: any;
-    constructor(moduleName: string | null, name: string | null, runtime?: any);
-}
-export declare class ConditionalExpr extends Expression {
-    condition: Expression;
-    falseCase: Expression | null;
-    trueCase: Expression;
-    constructor(condition: Expression, trueCase: Expression, falseCase?: Expression | null, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): ConditionalExpr;
-}
-export declare class DynamicImportExpr extends Expression {
-    url: string;
-    constructor(url: string, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): DynamicImportExpr;
-}
-export declare class NotExpr extends Expression {
-    condition: Expression;
-    constructor(condition: Expression, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): NotExpr;
-}
-export declare class FnParam {
-    name: string;
-    type: Type | null;
-    constructor(name: string, type?: Type | null);
-    isEquivalent(param: FnParam): boolean;
-    clone(): FnParam;
-}
-export declare class FunctionExpr extends Expression {
-    params: FnParam[];
-    statements: Statement[];
-    name?: string | null | undefined;
-    constructor(params: FnParam[], statements: Statement[], type?: Type | null, sourceSpan?: ParseSourceSpan | null, name?: string | null | undefined);
-    isEquivalent(e: Expression | Statement): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    toDeclStmt(name: string, modifiers?: StmtModifier): DeclareFunctionStmt;
-    clone(): FunctionExpr;
-}
-export declare class ArrowFunctionExpr extends Expression {
-    params: FnParam[];
-    body: Expression | Statement[];
-    constructor(params: FnParam[], body: Expression | Statement[], type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): Expression;
-    toDeclStmt(name: string, modifiers?: StmtModifier): DeclareVarStmt;
-}
-export declare class UnaryOperatorExpr extends Expression {
-    operator: UnaryOperator;
-    expr: Expression;
-    parens: boolean;
-    constructor(operator: UnaryOperator, expr: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null, parens?: boolean);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): UnaryOperatorExpr;
-}
-export declare class BinaryOperatorExpr extends Expression {
-    operator: BinaryOperator;
-    rhs: Expression;
-    parens: boolean;
-    lhs: Expression;
-    constructor(operator: BinaryOperator, lhs: Expression, rhs: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null, parens?: boolean);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): BinaryOperatorExpr;
-}
-export declare class ReadPropExpr extends Expression {
-    receiver: Expression;
-    name: string;
-    constructor(receiver: Expression, name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    get index(): string;
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    set(value: Expression): WritePropExpr;
-    clone(): ReadPropExpr;
-}
-export declare class ReadKeyExpr extends Expression {
-    receiver: Expression;
-    index: Expression;
-    constructor(receiver: Expression, index: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    set(value: Expression): WriteKeyExpr;
-    clone(): ReadKeyExpr;
-}
-export declare class LiteralArrayExpr extends Expression {
-    entries: Expression[];
-    constructor(entries: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null);
-    isConstant(): boolean;
-    isEquivalent(e: Expression): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): LiteralArrayExpr;
-}
-export declare class LiteralMapEntry {
-    key: string;
-    value: Expression;
-    quoted: boolean;
-    constructor(key: string, value: Expression, quoted: boolean);
-    isEquivalent(e: LiteralMapEntry): boolean;
-    clone(): LiteralMapEntry;
-}
-export declare class LiteralMapExpr extends Expression {
-    entries: LiteralMapEntry[];
-    valueType: Type | null;
-    constructor(entries: LiteralMapEntry[], type?: MapType | null, sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): LiteralMapExpr;
-}
-export declare class CommaExpr extends Expression {
-    parts: Expression[];
-    constructor(parts: Expression[], sourceSpan?: ParseSourceSpan | null);
-    isEquivalent(e: Expression): boolean;
-    isConstant(): boolean;
-    visitExpression(visitor: ExpressionVisitor, context: any): any;
-    clone(): CommaExpr;
-}
-export interface ExpressionVisitor {
-    visitReadVarExpr(ast: ReadVarExpr, context: any): any;
-    visitWriteVarExpr(expr: WriteVarExpr, context: any): any;
-    visitWriteKeyExpr(expr: WriteKeyExpr, context: any): any;
-    visitWritePropExpr(expr: WritePropExpr, context: any): any;
-    visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any;
-    visitInstantiateExpr(ast: InstantiateExpr, context: any): any;
-    visitLiteralExpr(ast: LiteralExpr, context: any): any;
-    visitExternalExpr(ast: ExternalExpr, context: any): any;
-    visitConditionalExpr(ast: ConditionalExpr, context: any): any;
-    visitDynamicImportExpr(ast: DynamicImportExpr, context: any): any;
-    visitNotExpr(ast: NotExpr, context: any): any;
-    visitFunctionExpr(ast: FunctionExpr, context: any): any;
-    visitUnaryOperatorExpr(ast: UnaryOperatorExpr, context: any): any;
-    visitBinaryOperatorExpr(ast: BinaryOperatorExpr, context: any): any;
-    visitReadPropExpr(ast: ReadPropExpr, context: any): any;
-    visitReadKeyExpr(ast: ReadKeyExpr, context: any): any;
-    visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any;
-    visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
-    visitCommaExpr(ast: CommaExpr, context: any): any;
-    visitWrappedNodeExpr(ast: WrappedNodeExpr<any>, context: any): any;
-    visitTypeofExpr(ast: TypeofExpr, context: any): any;
-    visitArrowFunctionExpr(ast: ArrowFunctionExpr, context: any): any;
-}
-export declare const NULL_EXPR: LiteralExpr;
-export declare const TYPED_NULL_EXPR: LiteralExpr;
-export declare enum StmtModifier {
-    None = 0,
-    Final = 1,
-    Private = 2,
-    Exported = 4,
-    Static = 8
-}
-export declare class LeadingComment {
-    text: string;
-    multiline: boolean;
-    trailingNewline: boolean;
-    constructor(text: string, multiline: boolean, trailingNewline: boolean);
-    toString(): string;
-}
-export declare class JSDocComment extends LeadingComment {
-    tags: JSDocTag[];
-    constructor(tags: JSDocTag[]);
-    toString(): string;
-}
-export declare abstract class Statement {
-    modifiers: StmtModifier;
-    sourceSpan: ParseSourceSpan | null;
-    leadingComments?: LeadingComment[] | undefined;
-    constructor(modifiers?: StmtModifier, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[] | undefined);
-    /**
-     * Calculates whether this statement produces the same value as the given statement.
-     * Note: We don't check Types nor ParseSourceSpans nor function arguments.
-     */
-    abstract isEquivalent(stmt: Statement): boolean;
-    abstract visitStatement(visitor: StatementVisitor, context: any): any;
-    hasModifier(modifier: StmtModifier): boolean;
-    addLeadingComment(leadingComment: LeadingComment): void;
-}
-export declare class DeclareVarStmt extends Statement {
-    name: string;
-    value?: Expression | undefined;
-    type: Type | null;
-    constructor(name: string, value?: Expression | undefined, type?: Type | null, modifiers?: StmtModifier, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
-    isEquivalent(stmt: Statement): boolean;
-    visitStatement(visitor: StatementVisitor, context: any): any;
-}
-export declare class DeclareFunctionStmt extends Statement {
-    name: string;
-    params: FnParam[];
-    statements: Statement[];
-    type: Type | null;
-    constructor(name: string, params: FnParam[], statements: Statement[], type?: Type | null, modifiers?: StmtModifier, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
-    isEquivalent(stmt: Statement): boolean;
-    visitStatement(visitor: StatementVisitor, context: any): any;
-}
-export declare class ExpressionStatement extends Statement {
-    expr: Expression;
-    constructor(expr: Expression, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
-    isEquivalent(stmt: Statement): boolean;
-    visitStatement(visitor: StatementVisitor, context: any): any;
-}
-export declare class ReturnStatement extends Statement {
-    value: Expression;
-    constructor(value: Expression, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
-    isEquivalent(stmt: Statement): boolean;
-    visitStatement(visitor: StatementVisitor, context: any): any;
-}
-export declare class IfStmt extends Statement {
-    condition: Expression;
-    trueCase: Statement[];
-    falseCase: Statement[];
-    constructor(condition: Expression, trueCase: Statement[], falseCase?: Statement[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
-    isEquivalent(stmt: Statement): boolean;
-    visitStatement(visitor: StatementVisitor, context: any): any;
-}
-export interface StatementVisitor {
-    visitDeclareVarStmt(stmt: DeclareVarStmt, context: any): any;
-    visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any;
-    visitExpressionStmt(stmt: ExpressionStatement, context: any): any;
-    visitReturnStmt(stmt: ReturnStatement, context: any): any;
-    visitIfStmt(stmt: IfStmt, context: any): any;
-}
-export declare function leadingComment(text: string, multiline?: boolean, trailingNewline?: boolean): LeadingComment;
-export declare function jsDocComment(tags?: JSDocTag[]): JSDocComment;
-export declare function variable(name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null): ReadVarExpr;
-export declare function importExpr(id: ExternalReference, typeParams?: Type[] | null, sourceSpan?: ParseSourceSpan | null): ExternalExpr;
-export declare function importType(id: ExternalReference, typeParams?: Type[] | null, typeModifiers?: TypeModifier): ExpressionType | null;
-export declare function expressionType(expr: Expression, typeModifiers?: TypeModifier, typeParams?: Type[] | null): ExpressionType;
-export declare function transplantedType<T>(type: T, typeModifiers?: TypeModifier): TransplantedType<T>;
-export declare function typeofExpr(expr: Expression): TypeofExpr;
-export declare function literalArr(values: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null): LiteralArrayExpr;
-export declare function literalMap(values: {
-    key: string;
-    quoted: boolean;
-    value: Expression;
-}[], type?: MapType | null): LiteralMapExpr;
-export declare function unary(operator: UnaryOperator, expr: Expression, type?: Type, sourceSpan?: ParseSourceSpan | null): UnaryOperatorExpr;
-export declare function not(expr: Expression, sourceSpan?: ParseSourceSpan | null): NotExpr;
-export declare function fn(params: FnParam[], body: Statement[], type?: Type | null, sourceSpan?: ParseSourceSpan | null, name?: string | null): FunctionExpr;
-export declare function arrowFn(params: FnParam[], body: Expression | Statement[], type?: Type | null, sourceSpan?: ParseSourceSpan | null): ArrowFunctionExpr;
-export declare function ifStmt(condition: Expression, thenClause: Statement[], elseClause?: Statement[], sourceSpan?: ParseSourceSpan, leadingComments?: LeadingComment[]): IfStmt;
-export declare function literal(value: any, type?: Type | null, sourceSpan?: ParseSourceSpan | null): LiteralExpr;
-export declare function isNull(exp: Expression): boolean;
-export declare const enum JSDocTagName {
-    Desc = "desc",
-    Id = "id",
-    Meaning = "meaning",
-    Suppress = "suppress"
-}
-export type JSDocTag = {
-    tagName: JSDocTagName | string;
-    text?: string;
-} | {
-    tagName?: undefined;
-    text: string;
-};