@neo-one/smart-contract-compiler/dist/cjs/analysis/AnalysisService.d.ts

NEO•ONE TypeScript smart contract compiler.

import { ECPoint, UInt160, UInt256 } from '@neo-one/client-common';
import { AnyNameableNode } from '@neo-one/ts-utils';
import ts from 'typescript';
import { Context } from '../Context';
export interface ErrorDiagnosticOptions {
    readonly error?: boolean;
}
export interface DiagnosticOptions extends ErrorDiagnosticOptions {
    readonly warning?: boolean;
}
export declare const DEFAULT_DIAGNOSTIC_OPTIONS: {
    error: boolean;
    warning: boolean;
};
export interface SignatureTypes {
    readonly paramDecls: ReadonlyArray<ts.ParameterDeclaration>;
    readonly paramTypes: Map<ts.ParameterDeclaration, ts.Type | undefined>;
    readonly returnType: ts.Type | undefined;
}
export declare class AnalysisService {
    private readonly context;
    private readonly memoized;
    constructor(context: Context);
    getFunctionReturnType(node: ts.SignatureDeclaration, options?: DiagnosticOptions): ts.Type | undefined;
    extractAllSignatures(node: ts.Node, options?: DiagnosticOptions): ReadonlyArray<SignatureTypes>;
    extractSignature(node: ts.Node, options?: DiagnosticOptions): SignatureTypes | undefined;
    getSignatures(node: ts.CallLikeExpression): ReadonlyArray<ts.Signature> | undefined;
    extractAllSignaturesForType(node: ts.Node, type: ts.Type | undefined, options?: DiagnosticOptions): ReadonlyArray<SignatureTypes>;
    extractSignatureForType(node: ts.Node, type: ts.Type | undefined, options?: DiagnosticOptions): SignatureTypes | undefined;
    extractSignaturesForCall(node: ts.CallLikeExpression, options?: DiagnosticOptions): ReadonlyArray<SignatureTypes> | undefined;
    extractSignatureTypes(node: ts.Node, signature: ts.Signature, options?: DiagnosticOptions): SignatureTypes | undefined;
    extractLiteralAddress(original: ts.Expression): UInt160 | undefined;
    extractLiteralHash256(original: ts.Expression): UInt256 | undefined;
    extractLiteralPublicKey(original: ts.Expression): ECPoint | undefined;
    getType(node: ts.Node, options?: ErrorDiagnosticOptions): ts.Type | undefined;
    getTypeOfSymbol(symbol: ts.Symbol | undefined, node: ts.Node): ts.Type | undefined;
    getSymbol(node: ts.Node): ts.Symbol | undefined;
    getTypeSymbol(node: ts.Node): ts.Symbol | undefined;
    getSymbolForType(_node: ts.Node, type: ts.Type | undefined): ts.Symbol | undefined;
    getNotAnyType(node: ts.Node, type: ts.Type | undefined, { error }?: ErrorDiagnosticOptions): ts.Type | undefined;
    extractStorageKey(node: ts.Node): string | undefined;
    isSmartContract(node: ts.ClassDeclaration): boolean;
    isSmartContractNode(node: ts.Node): boolean;
    getSymbolAndAllInheritedSymbols(node: ts.Node): ReadonlyArray<ts.Symbol>;
    isValidStorageType(node: ts.Node, type: ts.Type): boolean;
    findReferencesAsNodes(node: AnyNameableNode | ts.Identifier): ReadonlyArray<ts.Node>;
    isSmartContractMixinFunction(node: ts.FunctionDeclaration | ts.FunctionExpression): boolean;
    private isValidStorageArray;
    private isValidStorageMap;
    private isValidStorageSet;
    private extractLiteral;
    private traceIdentifier;
    private unwrapExpression;
    private report;
}