java2ib/dist/transformer.d.ts

TypeScript library that converts Java code into IB Computer Science pseudocode format

/**
 * AST Transformation System for converting Java AST to IB Pseudocode AST
 */
import { ASTNode, NodeType, SourceLocation, ConversionError } from './types';
import { IBRulesEngine, VariableInfo, MethodInfo } from './ib-rules-engine';
export interface PseudocodeNode {
    type: PseudocodeNodeType;
    content: string;
    indentLevel: number;
    children?: PseudocodeNode[];
    location: SourceLocation;
}
export declare enum PseudocodeNodeType {
    STATEMENT = "statement",
    BLOCK = "block",
    EXPRESSION = "expression",
    COMMENT = "comment"
}
export interface TransformationContext {
    variables: Map<string, VariableInfo>;
    methods: Map<string, MethodInfo>;
    currentScope: ScopeInfo;
    ibRules: IBRulesEngine;
    indentLevel: number;
}
export interface ScopeInfo {
    name: string;
    type: 'global' | 'class' | 'method' | 'block';
    parent?: ScopeInfo;
}
export interface TransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare abstract class BaseTransformationRule implements TransformationRule {
    abstract nodeType: NodeType;
    abstract transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    protected createPseudocodeNode(type: PseudocodeNodeType, content: string, location: SourceLocation, indentLevel?: number, children?: PseudocodeNode[]): PseudocodeNode;
    protected transformChildren(children: ASTNode[] | undefined, context: TransformationContext): PseudocodeNode[];
}
export declare class VariableDeclarationRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private isScannerObject;
    private isScannerInputMethod;
}
export declare class AssignmentRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private isScannerObject;
    private isScannerInputMethod;
}
export declare class BinaryExpressionRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class IdentifierRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class LiteralRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class IfStatementRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private transformStatementBody;
}
export declare class WhileLoopRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private transformStatementBody;
}
export declare class ForLoopRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private isEnhancedForLoop;
    private extractEnhancedForInfo;
    private isSimpleCountingLoop;
    private extractSimpleLoopInfo;
    private transformStatementBody;
}
export declare class MethodDeclarationRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class ArrayAccessRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class MethodCallRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private getObjectName;
    private isStringObject;
    private isScannerObject;
    private isScannerInputMethod;
}
export declare class ProgramRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class ReturnStatementRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class ClassDeclarationRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private findMainMethod;
    private isMainMethod;
    private shouldExtractMainMethod;
}
export declare class ASTTransformer {
    private rules;
    private ibRules;
    private errors;
    constructor();
    private initializeRules;
    /**
     * Transform a Java AST into IB Pseudocode AST
     * @param ast - The Java AST to transform
     * @returns Transformation result with pseudocode AST, errors, and warnings
     */
    transform(ast: ASTNode): {
        pseudocodeAST: PseudocodeNode[];
        errors: ConversionError[];
        warnings: ConversionError[];
    };
    /**
     * Transform a single AST node
     * @param node - The AST node to transform
     * @param context - The transformation context
     * @returns Array of pseudocode nodes
     */
    transformNode(node: ASTNode, context: TransformationContext): PseudocodeNode[];
    private addError;
    private addWarning;
    /**
     * Create a transformation context for testing
     * @param ibRules - Optional IBRulesEngine instance
     * @returns A new transformation context
     */
    createContext(ibRules?: IBRulesEngine): TransformationContext;
}
declare module './transformer' {
    interface TransformationContext {
        transformer: ASTTransformer;
    }
}
export declare class SwitchStatementRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class CaseClauseRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class DefaultClauseRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class BreakStatementRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class ContinueStatementRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class EnhancedForLoopRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
export declare class ArrayInitializationRule extends BaseTransformationRule {
    nodeType: NodeType;
    transform(node: ASTNode, context: TransformationContext): PseudocodeNode[];
}
//# sourceMappingURL=transformer.d.ts.map