Kipper Compiler Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

Unreleased

0.10.4 - 2023-08-15

Changed

• Moved function executeKipperProgram to Run as a private function.
• Moved class KipperCompileResult to new file compile-result.ts in the same directory.
• Field KipperCompileResult.programCtx can now be also undefined, due to the changed behaviour that now a KipperCompileResult is also returned for syntax errors (where it has no value).

Fixed

• CLI error handling bug as described in #491. This includes multiple bugs where errors were reported as "Unexpected CLI Error".

Deprecated

• CLI flag --abort-on-first-error in favour of --no-recover. #501.

0.10.3 - 2023-07-22

Added

• New modules in @kipper/cli:
  • input, which contains all input-related handling functions and classes.
  • output, which contains the output-related handling functions and classes.
• New decorator prettifiedErrors in @kipper/cli, which applies standardised error formatting to any thrown error.

Changed

• Standardised error output for the CLI as described in #435.
• Error message of KipperInternalError, which does not have " - Report this bug to the developer using the traceback!" as a suffix anymore.
• Changed success message of the kipper analyse command Finished code analysis in ... to Done in ....
• Renamed getFile to getParseStream.

Fixed

• CLI bug where the -t shortcut flag was incorrectly shown for the command help compile. (#451)

0.10.2 - 2023-06-16

Added

• New field:
  • KipperError.programCtx, which contains, if KipperError.tracebackData.errorNode is not undefined, the program context of the error.
• New function:
  • ensureScopeDeclarationAvailableIfNeeded, which ensures that a scope declaration is available if needed. This is used during the semantic analysis/type checking of a declaration statement, which may need the scope declaration object during the processing.

Fixed

• Redeclaration bug causing an InternalError after calling the compiler (#462).
• Compiler argument bug in KipperCompiler, where abortOnFirstError didn't precede recover, meaning that instead of an error being thrown the failed result was returned (As defined in the recover behaviour, which is incorrect).
• Bug of invalid underline indent in error traceback. (#434).

0.10.1 - 2023-02-21

Fixed

• Bug causing the compiler to not detect the expected useless statement warning for a useless arithmetic expression. (#426).

0.10.0 - 2023-02-19

Added

• Added full support for custom-defined functions, function arguments, function return evaluation, function scopes/argument referencing and return-value code branch inspection. (#183).
• Implemented while-loop iteration statements (#268).
• Implemented for-loop iteration statements (#270).
• JavaScript compilation target with a new monorepo package called @kipper/target-js, which implements the semantic analysis and code generation for JavaScript, and provides the class KipperJavaScriptTarget (TargetTS available as alias), which can be used as the target in the CompileConfig. (#208).
• Standalone web-module package called @kipper/web, which from now on will provide the kipper-standalone.js script that can be used in a web-application. This also bundles @kipper/target-js and @kipper/target-ts, which can be also accessed using the identifiers KipperJS and KipperTS in the web environment. (#86).
• Implemented arithmetic assignment operators +=, -=, *=, %= and /= (#273).
• Support for unary and postfix increment and decrement (++, --) expressions (#272).
• Implemented member-access expressions using bracket and slice notation ([], [:]), which can be used to access specific elements of a string (In the future, this will also be used to access elements of arrays and objects). (#372).
• Support for single-line comments separated by a newline char. (#400).
• Implemented new built-in function len(), which returns the length of a string (In the future also arrays). (#411).
• Support for jump statements continue and break for iteration statements. (#269).
• New built-in variable __name__ returning the name of the current file. This also includes general support for built-in variables in the compiler. (#412).
• New built-in Kipper type null and undefined, and support for the constant identifier void, null and undefined.
• Finished implementation of warning reporting system and added warning for useless expression statements. (#413).
• New Kipper CLI flag -t/--target to specify the target to use for a compilation or execution.
• Use of "use strict"; in the TypeScript target to enforce the use of strict mode during runtime.
• New generic parameter TypeSemantics to ASTNode, which defines the type data that the AST Node should evaluate during type checking.
• New CLI flags for commands run and compile:
  • --log-timestamp, which enables timestamps for the log messages.
  • --recover, which enables error recovery for the Kipper compiler.
  • --abort-on-first-error, which aborts the compilation on the first compiler error that is encountered.
• New errors/warnings:
  • MissingFunctionBodyError, which is thrown when a function declaration is missing a body (compound statement).
  • LexerOrParserSyntaxError, which is thrown when the lexer or parser encounters a syntax error.
  • IdentifierAlreadyUsedByParameterError, which is thrown when an identifier is already used by a parameter in the same scope or any parent scope.
  • ExpressionNotCallableError, which is thrown when an expression is not callable, despite it being used in a call expression.
  • IncompleteReturnsInCodePathsError, which is thrown whenever a non-void function has code paths that do not return a value.
  • ReturnStatementError, which is thrown whenever a return statement is used outside a function.
  • InvalidUnaryExpressionOperandError, which is thrown whenever a unary expression is used with an invalid operand.
  • UndefinedDeclarationCtxError, which is thrown when the declaration context of a declaration is undefined. (This is an internal error that happens if the declaration context is accessed too early e.g. before its creation.)
  • TypeNotCompilableError, which is thrown when an invalid/undefined type is cast to a compilable type, despite it being invalid. (This is an internal error that happens if the type is cast during compilation despite it having errored during semantic analysis/type checking.)
  • InvalidKeyTypeError, which is thrown when an expression with an invalid type is used as a key/index to access an object-like or array-like.
  • ValueNotIndexableTypeError, which is thrown when a value is not indexable (not object-like), despite it being used in a member access expression.
  • MissingRequiredSemanticDataError, which is a specific internal error used to indicate that a specified node is missing required semantic data from another node and as a result failed to process itself.
  • UselessExpressionStatementWarning, which is reported when an expression statement is used without any side-effects and as such does not have any effect on the program.
• New classes/interfaces:
  • KipperWarning, which is a subclass of KipperError that is used to indicate a warning. This replaces the use of KipperError for warnings.
  • ReturnStatement, which is a subclass of Statement that represents a return statement. This is not anymore included in the JumpStatement class.
  • FunctionScope, which is a subclass of Scope that represents a function scope with registered parameters.
  • UndefinedCustomType, which represents an invalid/undefined type that was created by the user, but is not defined in the program. This is used to allow error recovery and continue even with an invalid type during type checking, and let the type checker know to ignore type checks with references of this type.
  • Type, which is an abstract base class for defining a wrapper class for a Kipper type during semantic analysis and type checking.
  • UncheckedType, which is an implementation of Type and represents a raw specified type during semantic analysis.
  • CheckedType, which is an implementation of Type and represents a checked type during type checking, which also handles compatibility and error recovery for undefined types.
  • MemberAccessExpression, which is a subclass of Expression that represents a member access expression (Antlr4 rule memberAccessExpression).
  • AnalysableASTNode, which represents an AST node that can be semantically processed. This class was created as a parent class for CompilableASTNode, as a way to split up the semantic analysis and code generation.
  • KipperWarningIssuer, which is a class similar to KipperSemanticChecker and checks for certain conditions and reports warnings if they are met.
  • ScopeNode<T>, which is an interface representing an AST node that implements its own local scope. This means that the definitions of its children, will be stored in the innerScope field of the class implementation.
  • SymbolTable, which implements the basic functionality of a symbol table containing the metadata for a scope.
  • MemberAccessExpressionSemantics, which represents the semantics for MemberAccessExpression.
  • MemberAccessExpressionTypeSemantics, which represents the type semantics for MemberAccessExpression.
  • TargetAnalysableNode, which represents an AST node that has a target-specific semantic analysis function.
  • TargetCompilableNode, which represents an AST node that has a target-specific code generation function.
  • ASTNodeFactory, which represents a basic factory for creating AST nodes.
  • InternalFunctionArgument, which represents an internal function argument.
  • InternalReference<T>, which represents an indirect reference to an internal function by the user. This is primarily used to keep track of the internal functions that are used in the program, and to generate them in the target code.
• New functions:
  • KipperTargetCodeGenerator.setUp(), which should generate SetUp code for the specified target.
  • KipperTargetCodeGenerator.wrapUp(), which should generate WrapUp code for the specified target.
  • ASTNode.getTypeSemanticData(), which returns the type semantics if they are defined, otherwise throws an UndefinedSemanticsError.
  • CompilableASTNode.semanticTypeChecking(), which performs type checking for the AST node and its children nodes. This is called in the function RootASTNode.semanticAnalysis after CompilableASTNode.semanticAnalysis().
  • CompilableASTNode.wrapUpSemanticAnalysis(), which performs wrap-up semantic analysis for the target of the AST node. This is called in the function RootASTNode.semanticAnalysis after CompilableASTNode.semanticTypeChecking().
  • Scope.getReferenceRecursively(), which tries to evaluate a reference recursively in the scope and its parent scopes.
  • KipperTypeChecker.validReturnStatement(), which ensures that a return statement is only used inside a function.
  • KipperTypeChecker.checkMatchingTypes(), which checks if the two specified types are matching.
  • KipperTypeChecker.referenceCallable(), which asserts that the specified reference is a callable function.
  • KipperTypeChecker.validReturnCodePathsInFunctionBody(), which ensures that all code paths of a non-void function return a proper value.
  • KipperSemanticChecker.identifierNotUsed(), which asserts that the specified identifier is unused in the specified scope and can be used for a new declaration.
  • KipperSemanticChecker.getReturnStatementParent(), which evaluates the parent function for a return statement.
  • KipperSemanticChecker.refTargetDefined(), which asserts that the specified reference is defined and can be used.
  • KipperSemanticChecker.validFunctionBody(), which ensures the body of a function is a compound statement.
  • CompilableASTNode.addError(), which adds an error to the list of errors caused by the node.
  • removeBraces() for removing braces due to formatting reasons.
  • CompilableASTNode.recursivelyCheckForWarnings(), which recursively calls all children's checkforWarnings() functions as well as the function of the parent instance.
  • shouldRecoverFromError() and handleSemanticError() in handle-error.ts.
  • AnalysableASTNode.semanticallyAnalyseChildren(), which semantically analyses all children nodes of the AST node.
  • AnalysableASTNode.semanticallyTypeCheckChildren(), which semantically type checks all children nodes of the AST node.
  • AnalysableASTNode.targetSemanticallyAnalyseChildren(), which semantically analyses all children nodes of the AST node for the target.
  • AnalysableASTNode.ensureSemanticallyValid(), which throws a MissingRequiredSemanticDataError in case that the specified node failed during semantic analysis. This is used by other nodes to ensure that the node is valid and its data can be safely accessed.
  • AnalysableASTNode.ensureTypeSemanticallyValid(), which throws a MissingRequiredSemanticDataError in case that the specified node failed during type checking. This is used by other nodes to ensure that the node is valid and its data can be safely accessed.
  • KipperSemanticChecker.getJumpStatementParent(), which evaluates the parent iteration statement for a jump statement.
  • KipperProgramContext.registerBuiltInFunctions(), which registers one or more built-in functions.
  • KipperProgramContext.registerBuiltInVariables(), which registers one or more built-in variables.
  • KipperProgramContext.clearBuiltInFunctions(), which clears the list of built-in functions.
  • KipperProgramContext.clearBuiltInVariables(), which clears the list of built-in variables.
  • KipperProgramContext.getBuiltInVariable(), which returns the built-in variable with the specified name if found.
  • KipperProgramContext.builtInFunctionReferences, which stores all the references to built-in functions.
  • KipperProgramContext.builtInVariableReferences, which stores all the references to built-in variables.
• New types:
  • TypeData, which represents the type data of an ASTNode.
  • NoTypeSemantics, which hints that an ASTNode has no type semantic data.
  • TargetSetUpCodeGenerator, which represents a function that generates SetUp code for a Kipper file.
  • TargetWrapUpCodeGenerator, which represents a function that generates WrapUp code for a Kipper file.
  • KipperEqualAssignOperator, which represents the equal assignment operator (=).
  • KipperAssignOperator, which represents all available assignment operators.
  • KipperArithmeticAssignOperator, which represents all available arithmetic assignment operators.
  • KipperArg, which represents a function argument. Alias for KipperParam.
  • KipperParam, which represents a function parameter.
  • JmpStatementType, which represents all possible jump statement types e.g. break and continue.
  • ASTDeclarationKind, which is a union type of all possible ParserASTNode.kind values for a Declaration AST node.
  • ASTExpressionKind, which is a union type of all possible ParserASTNode.kind values for a Expression AST node.
  • ASTStatementKind, which is a union type of all possible ParserASTNode.kind values for a Statement AST node.
  • ASTConstantExpressionKind, which is a union type of all possible ParserASTNode.kind values for a ConstantExpression AST node.
  • ParserConstantExpressionContext, which is a union type of all possible ParserASTNode.antlrRuleCtx values for a ConstantExpression AST node.
  • ASTTypeSpecifierExpressionKind, which is a union type of all possible ParserASTNode.kind values for a TypeSpecifierExpression AST node.
  • ParserTypeSpecifierExpressionContext, which is a union type of all possible ParserASTNode.antlrRuleCtx values for a TypeSpecifierExpression AST node.
  • ASTUnaryExpressionKind, which is a union type of all possible ParserASTNode.kind values for a UnaryExpression AST node.
  • ParserUnaryExpressionContext, which is a union type of all possible ParserASTNode.antlrRuleCtx values for a UnaryExpression AST node.
  • ASTComparativeExpressionKind, which is a union type of all possible ParserASTNode.kind values for a ComparativeExpression AST node.
  • ParserComparativeExpressionContext, which is a union type of all possible ParserASTNode.antlrRuleCtx values for a ComparativeExpression AST node.
  • ConstructableASTStatementClass, which is a union type of all possible Statement AST node classes.
  • ASTLogicalExpressionKind, which is a union type of all possible ParserASTNode.kind values for a LogicalExpression AST node.
  • ParserLogicalExpressionContext, which is a union type of all possible Parserement AST node classes.
  • ConstructableASTExpressionClass, which is a union type of all possible Expression AST node classes.
  • ConstructableASTDeclarationClass, which is a union type of all possible Declaration AST node classes.
  • ConstructableASTNodeClass, which is a union type of all possible ASTNode AST node classes.
  • ConstructableASTStatement, which is a union type of all possible Statement AST node instances.
  • ConstructableASTExpression, which is a union type of all possible Expression AST node instances.
  • ConstructableASTDeclaration, which is a union type of all possible Declaration AST node instances.
  • ConstructableASTNode, which is a union type of all possible ASTNode AST node instances.
  • ASTKind, which represents a union of all AST node kind values that can be used to map a KipperParser rule context to an AST node. This is the type representing all values from ParserASTMapping.
  • ConstructableASTKind, which is the same as ASTKind, but removes any kind value that does not have a corresponding AST node class.
  • KipperReferenceableFunction, which represents a function that can be referenced by a FunctionCallExpression.
  • ASTNodeParserContext, which represents a union of all possible ParserASTNode.antlrRuleCtx values implemented in the KipperParser that have a corresponding AST node class.
• New fields/properties:
  • CompileConfig.recover, which if set enables compiler error recovery.
  • CompileConfig.abortOnFirstError, which changes the compiler error handling behaviour and makes it abort on the first error encountered. This overwrites recover per default.
  • RootASTNode.target, which returns the KipperCompileTarget of the program ctx the root AST node is in.
  • RootASTNode.codeGenerator, which returns the KipperTargetCodeGenerator of the program ctx the root AST node is in.
  • RootASTNode.semanticAnalyser, which returns the KipperTargetSemanticAnalyser of the program ctx the root AST node is in.
  • ASTNode.typeSemantics, which contains the type data for an ASTNode that was evaluated during type checking.
  • ScopeFunctionDeclaration.typeData, which returns the type data of the function AST node.
  • ScopeVariableDeclaration.typeData, which returns the type data of the variable AST node.
  • ScopeVariableDeclaration.valueWasUpdated, which returns true if the variable was updated after its initial declaration.
  • ScopeDeclaration.isDefined, which is an abstract field that returns whether the scope declaration was defined during its declaration.
  • ScopeDeclaration.hasValue, which is an abstract field that returns whether the scope declaration has a value set.
  • FunctionDeclaration.innerScope, which returns the inner scope of the function declaration. This can be used before semantic analysis, though will return undefined if it encounters any error.
  • TracebackMetadata.errorNode, which contains the error node that caused the error.
  • CompilableASTNode.errors and RootASTNode.errors, which returns all errors caused by this node and or its children.
  • KipperProgramContext.hasFailed, CompilableASTNode.hasFailed, RootASTNode.hasFailed, which returns true if the node or any of its children have failed to be processed during semantic analysis or type checking.
  • Scope.parent, which returns the parent scope of the scope. This is used to recursively evaluate references in all parent scopes.
  • ParserASTNode.kind, which returns the kind of the parser AST node. This returns the KipperParser rule number, as defined by KipperParser.RULE_*.
  • StatementASTNodeFactory.statementMatchTable, which returns the match table for the statement AST node factory.
  • ExpressionASTNodeFactory.expressionMatchTable, which returns the match table for the expression AST node factory.
  • DeclarationASTNodeFactory.declarationMatchTable, which returns the match table for the declaration AST node factory.
  • CompileConfig.builtInFunctions, which overwrites the built-in functions of the target.
  • CompileConfig.extendBuiltInFunctions, which adds new built-in functions to the target.
  • CompileConfig.builtInVariables, which overwrites the built-in variables of the target.
  • CompileConfig.extendBuiltInVariables, which adds new built-in variables to the target.
  • Expression.hasSideEffects, which returns true if the expression has side effects and as such affects the state of the program. This is primarily used for reporting warnings.
• New constants:
  • kipperNullType, which represents the Kipper null type.
  • kipperUndefinedType, which represents the Kipper undefined type.
  • ParserASTMapping, which is a special mapping object used to get the AST kind number for a KipperParser rule ctx instance.
  • kipperRuntimeBuiltInVariables, which contains the built-in variables of the Kipper runtime.

Changed

• Moved TypeScript target from the core package to a new monorepo package called @kipper/target-ts, which implements the semantic analysis and code generation for TypeScript, and provides the class KipperTypeScriptTarget (TargetTS available as alias), which can be used as the target in the CompileConfig.
• Updated behaviour of the Compiler semantic analysis and implemented a basic error recovery system. (#198)
• Updated behaviour of Kipper Compiler semantic analysis and separated primary semantic analysis, type checking and target-specific semantic analysis into their own processing steps. (E.g. First, all AST nodes are semantically analysed, then type checked and semantically analysed for the target language)
• Updated the built-in functions' generation behaviour, by making every built-in function be defined inside the global variable __kipper and the global object property globalThis.__kipper. This means that the functions are directly bound to the JS runtime and any function definition in the generated file is placed after the initial evaluation of the global scope.
• Updated the function call syntax and made the call keyword optional. This allows for simplified function calls, such as print("Hello world!");.
• Default error identifier is now just Error instead of KipperError.
• Migrated the internal storage of Scope and its implementing classes to a hashmap implementation.
• Updated types of CompilableASTNode functions primarySemanticAnalysis, primarySemanticTypeChecking and targetSemanticAnalysis and made them possibly undefined if there is nothing to check. This is to improve performance and not call an async function unnecessarily.
• Allowed the use of function declarations inside nested scopes (e.g. inside a function body or compound statement).
• Split grammar file Kipper.g4 into KipperLexer.g4 and KipperParser.g4.
• Updated factory system for StatementASTNodeFactory, DeclarationASTNodeFactory and ExpressionASTNodeFactory to use a mapping table instead of a switch statement for better readability and accessibility. This also allows for easier extension of the factory system. The create function is now instance-based (not static anymore) as well.
• Constructor in KipperParseStream to allow either an CharPointCharStream or a string as input, but not allow a mismatch content between the two.
• Cleaned up structure in KipperFileASTGenerator (previously KipperFileListener) and removed unnecessary code.
• Renamed:
  • EvaluatedCompileOptions to EvaluatedCompileConfig.
  • UnableToDetermineMetadataError to UndefinedSemanticsError.
  • ReadOnlyAssignmentTypeError to ReadOnlyWriteTypeError.
  • InvalidAssignmentTypeError to AssignmentTypeError.
  • InvalidArgumentTypeError to ArgumentTypeError.
  • InvalidArithmeticOperationTypeError to ArithmeticOperationTypeError.
  • InvalidReturnTypeError to FunctionReturnTypeError.
  • UndefinedIdentifierError to UndefinedReferenceError.
  • UnknownIdentifierError to UnknownReferenceError.
  • FunctionDeclarationSemantics.args to params.
  • KipperTypeChecker.argumentTypesMatch to validArgumentValue.
  • ListPrimaryExpression to ArrayLiteralPrimaryExpression.
  • FunctionCallPostfixExpression to FunctionCallExpression.
  • antlrDefinitionCtxType to ParserDeclarationCtx.
  • antlrExpressionCtxType to ParserExpressionCtx.
  • antlrStatementCtxType to ParserStatementCtx.
  • ParserExpressionCtx to ParserExpressionContext.
  • ParserStatementCtx to ParserStatementContext.
  • ParserDeclarationCtx to ParserDeclarationContext.
  • KipperFileListener to KipperFileASTGenerator.
  • KipperProgramContext.addError to reportError.
  • kipperRuntimeBuiltIns to kipperRuntimeBuiltInFunctions.
  • kipperInternalBuiltIns to kipperInternalBuiltInFunctions.
• Moved:
  • Function KipperSemanticsAsserter.getReference to class KipperSemanticChecker.
  • Function KipperSemanticsAsserter.getExistingReference to class KipperSemanticChecker.
  • Function indentLines to file tools.ts of @kipper/target-js.
  • Function CompilableASTNode.semanticAnalysis to AnalysableASTNode.
  • Function CompilableASTNode.semanticTypeChecking to AnalysableASTNode.
  • Function CompilableASTNode.wrapUpSemanticAnalysis to AnalysableASTNode.
  • Function CompilableASTNode.recursivelyCheckForWarnings to AnalysableASTNode.
  • Function CompilableASTNode.recursivelyCheckForWarnings to AnalysableASTNode.
  • Abstract Function CompilableASTNode.primarySemanticAnalysis to AnalysableASTNode.
  • Abstract Function CompilableASTNode.primarySemanticTypeChecking to AnalysableASTNode.
  • Abstract Function CompilableASTNode.checkForWarnings to AnalysableASTNode.
  • Field CompilableASTNode.programCtx to AnalysableASTNode.
  • Field CompilableASTNode.compileConfig to AnalysableASTNode.
  • Field CompilableASTNode.errors to AnalysableASTNode.
  • Field CompilableASTNode.addError to AnalysableASTNode.
  • Field CompilableASTNode.hasFailed to AnalysableASTNode.

Fixed

• Multiple reference and declaration bugs, which resulted in invalid handling of declarations and assignments to undefined variables and allowed the referencing of variables that were not defined or had no value set.
• Grammar bug which didn't allow the representation of empty lists (e.g. []).
• Multiple reference and declaration bugs, which resulted in invalid handling of declarations and assignments to undefined variables and allowed the referencing of variables that were not defined or had no value set.
• Grammar bug which didn't allow the representation of empty lists (e.g. []).
• A bug where using a KipperParseStream multiple times would result in the CodePointCharStream being empty.
• Grammar bug not allowing an empty statement (;) in a compound statement.

Removed

• Kipper CLI command update, as it was not needed since there are no plans to deploy S3 distributions of Kipper.
• KipperError.isWarning, which has been replaced by the new class KipperWarning.
• KipperCharType (char) and its grammar implementation, meaning all string types from now on will only be of type str. This also means that the single-quote character ' can from now also be used for string literals and f-strings with the same behaviour as the regular double-quoted character ".
• KipperReturnType and kipperReturnTypes, as they are always identical to the KipperType and kipperTypes respectively.
• FunctionReturnTypeError, as it is obsolete since all return types are valid.
• The following fields:
  • Scope.functions (replaced by hash-map implementation of Scope).
  • Scope.variables (replaced by hash-map implementation of Scope).
  • Scope.getVariable (replaced by hash-map implementation of Scope).
  • Scope.getFunction (replaced by hash-map implementation of Scope).
  • KipperError.antlrCtx, as it was replaced by TracebackMetadata.errorNode.
  • KipperTypeChecker.validReturnType, as it is obsolete due to the absence of KipperReturnType.
• The following functions:
  • KipperFileASTGenerator.handleIncomingDeclarationCtx (removed in clean-up).
  • KipperFileASTGenerator.handleIncomingStatementCtx (removed in clean-up).
  • KipperFileASTGenerator.handleExitingStatementOrDefinitionCtx (removed in clean-up).
  • KipperFileASTGenerator.handleIncomingExpressionCtx (removed in clean-up).
  • KipperFileASTGenerator.handleExitingExpressionCtx (removed in clean-up).
  • KipperProgramConext.builtInReferences (replaced by builtInFunctionReferences and builtInVariableReferences).
  • KipperProgramConext.registerBuiltIns (replaced by registerBuiltInFunctions and registerBuiltInVariables).
  • CompileConfig.builtIns (replaced by builtInFunctions and builtInVariables).
  • CompileConfig.extendBuiltIns (replaced by extendBuiltInFunctions and extendBuiltInVariables).
• Parser rule arraySpecifierExpression (ArraySpecifierExpression), which was made obsolete with the addition of bracketNotationMemberAccessExpression (BracketNotationMemberAccessExpression).

0.9.2 - 2022-07-23

Changed

• Fixed traceback bug for re-declarations inside compound statements generating an invalid error message and traceback. (#240)
• Updated Kipper compiler error message.

0.9.1 - 2022-06-29

Changed

• Fixed invalid traceback underline formatting for Kipper errors.
• Updated error messages in multiple Kipper errors.

0.9.0 - 2022-06-26

Added

• Entry point file for the root package kipper, which exports @kipper/core allowing the kipper package to be used in projects.
• Syntax support and code generation for if, else-if and else statements (#182).
• Code generation of expression lists (e.g. expression statements containing multiple child expressions) (#173).
• Code generation for tangled expressions. (#203)
• Comparative and relational expressions, which allow for logical operations and comparisons on expressions. List of all supported operators, which can be used between two expressions.
  • != (Not Equal Operator)
  • == (Equal Operator)
  • > (Greater than Operator)
  • >= (Greater or equal to Operator)
  • < (Less than Operator)
  • <= (Less or equal to Operator)
• Logical expressions, which allow for the chaining and combination of expressions and conditions. List of all available supported operators, which can be used between two expressions/conditions:
  • && (Logical And Operator)
  • || (Logical Or Operator)
• Operator modified expressions, which allow for the modification of an expression using a specific operator. List of all supported operators:
  • ! (Logical NOT Operator)
  • + (Plus Operator)
  • - (Minus Operator)
• Partial support for compiler warnings by allowing KipperError instances to be warnings if isWarning is set to true and implementing AST-based checks for warnings using the new function CompilableASTNode.checkForWarnings(). (#199)
• New flag -w/--warnings in the commands compile, run and analyse, which enables logger warnings. (#199)
• Support for hex, binary and octal numbers. (Only minor changes, as previously the syntax for binary, octal and hex numbers was already added.) (#184)
• New errors:
  • InvalidRelationalComparisonTypeError, which is thrown whenever a relational comparison is used with types that are not comparable.
  • InvalidUnaryExpressionTypeError, which is thrown whenever a unary expression has an operand with an invalid type.
• New classes:
  • IfStatement, which represents if, if-else and else statements. Chained if, else-if and else statements are structured like a tree, where the top if statement represents the root and each following if statement is a section/branch of the tree.
  • TypeSpecifierExpression, which is an abstract class used to provide the commonality between the different type specifier expressions.
  • ComparativeExpression, which is an abstract class used to provide the commonality between the different comparative expressions.
  • LogicalExpression, which is an abstract class used to provide the commonality between the different logical expressions.
  • UnaryExpression, which is an abstract class used to provide the commonality between the different unary expressions.
  • SwitchStatement, which represents a switch selection statement.
  • DefinitionASTNodeFactory, which is a factory that creates a definition instance based on a antlrRuleCtx.
  • ExpressionASTNodeFactory, which is a factory that creates an expression instance based on a antlrRuleCtx.
  • StatementASTNodeFactory, which is a factory that creates a statement instance based on a antlrRuleCtx.
• New types:
  • KipperUnaryOperator
  • KipperLogicalAndOperator
  • KipperLogicalOrOperator
  • KipperLogicalOperator
  • KipperEqualityOperator
  • KipperRelationalOperator
  • KipperComparativeOperator
  • KipperUnaryModifierOperator
  • KipperIncrementOrDecrementOperator
  • KipperNegateOperator
  • KipperSignOperator
• New constants:
  • kipperUnaryOperators
  • kipperLogicalAndOperator
  • kipperLogicalOrOperator
  • kipperLogicalOperator
  • kipperEqualityOperators
  • kipperRelationalOperators
  • kipperComparativeOperators
  • kipperIncrementOrDecrementOperators
  • kipperNegateOperators
  • kipperSignOperators
• New interfaces:
  • IfStatementSemantics, which contains the semantic data of an if-statement.
  • ComparativeExpressionSemantics, which defines the semantic data of a comparative expression.
  • LogicalExpressionSemantics, which defines the semantics of a logical expression.
  • UnaryExpressionSemantics, which defines the base semantics for every unary expression.
  • TracebackMetadata, which defines the required data for a full traceback in a KipperError.
• New functions:
  • CompilableASTNode.checkForWarnings(), which checks for warnings in an AST Node.
  • KipperTypeChecker.validRelationalExpression(), which ensures a RelationalExpression is semantically valid.
  • KipperTypeChecker.validUnaryExpression(), which ensures a UnaryExpression is semantically valid.
  • KipperProgramContext.addWarning(), which adds a warning to the program context.
  • KipperLogger.reportWarning(), which reports a warning with its traceback to the consoles.
• New fields/properties:
  • CompileConfig.warnings, which if set to true enables warnings and stores them in KipperCompileResult.warnings.
  • EvaluatedCompileOptions.warnings, which if set to true enables warnings and stores them in KipperCompileResult.warnings.
  • KipperCompileResult.warnings, which contains a list of all warnings that were found during the compilation of a program.
  • KipperError.isWarning, which if true defines the error as non-fatal warning that does not prevent the compilation from continuing.
  • KipperProgramContext.warnings, which contains all warnings that have been found in the program.
  • KipperLogger.reportWarnings, which if set to true will report warnings to the console.
  • KipperProgramContext.reportWarnings, which if set to true will run warning checks on the AST nodes of the program.

Changed

• Moved KipperSemanticChecker.arithmeticExpressionValid() to KipperTypeChecker and renamed it to validArithmeticExpression().
• Renamed Antlr4 rule singleTypeSpecifier to identifierTypeSpecifier and its associated class to IdentifierTypeSpecifierExpression.
• Renamed:
  • SingleTypeSpecifierExpression to IdentifierTypeSpecifierExpression.
  • ParserASTNode.getTokenChildren() to getAntlrRuleChildren().
  • Scope.localVariables to variables.
  • Scope.localFunctions to functions.
• Updated logging messages and shortened them to be more concise.

Removed

• Deprecated and replaced functions:
  • getDefinitionInstance, which was replaced with DefinitionASTNodeFactory.
  • getExpressionInstance, which was replaced with ExpressionASTNodeFactory.
  • getStatementInstance, which was replaced with StatementASTNodeFactory.

0.8.3 - 2022-06-18

Added

• New errors:
  • ReadOnlyAssignmentTypeError, which is thrown whenever a read-only (constant) variable is being assigned to.
  • InvalidAssignmentTypeError, which is thrown whenever an assignment has mismatching types that are not compatible.
  • UndefinedConstantError, which is thrown whenever a constant declaration is not defined. (Constants may not be undefined).

Changed

• Fixed const assignment bug #188, which allowed assignments to read-only (constant) variables.
• Fixed invalid identifier translation of built-in references in the TypeScript target.
• Renamed:
  • KipperProgramContext.registerGlobals() to registerBuiltIns.
  • InvalidConversionError to InvalidConversionTypeError
  • InvalidArithmeticOperationError to InvalidArithmeticOperationTypeError
• Set display error name of InvalidArithmeticOperationTypeError to TypeError.

0.8.2 - 2022-06-14

Changed

• Handling of integer constants and cleaned up the lexer rules in Kipper.g4.
• Updated error message of InvalidAmountOfArgumentsError.
• Updated and improved speed of space handling by optimising parser rules and removing manual spaces in rules.

Removed

• Integer and float suffixes from the lexer rules in Kipper.g4, as they are meaningless in Kipper.

0.8.1 - 2022-06-09

Changed

• Replaced outdated NotImplemented errors from KipperFileListener.ts with KipperNotImplementedError errors, which are now thrown inside the primarySemanticAnalysis() functions of the affected statements.
• Updated and simplified logging messages.
• Fixed grammar issue in Kipper.g4, which resulted in spaces being syntactically invalid in an empty function argument list, e.g. def func( ) -> void; was invalid before.

Removed

• Unused grammar rule nestedParenthesesBlock.

0.8.0 - 2022-06-07

Added

• Implemented type conversion expressions, which allow for the conversion of a value to another type. (#133) The following conversions are supported:
  • str as num
  • num as str
  • bool as str
  • bool as num
• Boolean constant expressions true and false, which automatically evaluate to the type bool and can be used in expressions. (true and false are now reserved identifiers, which can never be overwritten and any attempts to do so will be blocked by the parser). This also includes a new expression class BoolPrimaryExpression, a new target-specific semantics function KipperTargetSemanticAnalyser.boolPrimaryExpression and target-specific translation function KipperTargetCodeGenerator.boolPrimaryExpression. (#134)
• Implemented reserved identifier checking, which ensures that no declarations overwrite/interfere with an internal identifier or reserved identifier/keyword. (#153)
• Implemented tree-shaking for internal and built-in functions using the new class KipperOptimiser, which removes any function definitions that are not used (#159).
• New field KipperCompileTarget.builtInGenerator, which will store the built-in generator for each target.
• New classes and interfaces:
  • KipperTargetBuiltInGenerator, which updates the behaviour for generating built-in functions. This function should also allow the use of built-in variables in the future and also provide a basis for dynamic dependency generation for the Kipper built-ins. This means that targets can now specify themselves how the built-in should be generated and can handle all type conversions, internal prefixes, name mangling etc. themselves.
  • identifierTypeSpecifierExpression, which represents a single constant type identifier, such as str.
  • GenericTypeSpecifierExpression, which represents a generic type constant, such as type<T>. (Functionality not implemented yet! Planned for v0.12)
  • TypeofTypeSpecifierExpression, which represents a dynamically evaluated type, such as typeof("string"). (Functionality not implemented yet! Planned for v0.11)
  • InternalFunction, which represents an internal function for Kipper, which provides specific functionality for keywords and other internal logic.
  • KipperSemanticErrorHandler, which implements a default abstract error handler for semantic errors. This is used by KipperTargetSemanticAnalyser and KipperAsserter.
  • KipperOptimiser, which handles code optimisation for a Kipper program.
• New functions:
  • KipperSemanticChecker.validConversion(), which checks whether a type conversion is valid and implemented by Kipper.
  • KipperOptimiser.optimise(), which performs optimisation on an abstract syntax tree.
  • KipperProgramContext.getBuiltInFunction(), which searches for a built-in function based on a passed identifier.
  • KipperProgramContext.optimise(), which performs code optimisations for the local abstract syntax tree.
• New errors:
  • InvalidConversionError, which is thrown when an invalid or unimplemented conversion is performed in a Kipper program.
  • ReservedIdentifierOverwriteError, which is thrown whenever a declaration identifier overwrites/interferes with an internal function or reserved keyword/identifier.
• New types and constants:
  • Kipper meta type type, which represents the type of a Kipper type.
  • kipperSupportedConversions, which is an array containing multiple tuples representing allowed conversions in Kipper.
• New CompileConfig option optimisationOptions, which contains the configuration for the KipperOptimiser.
• Added new flags -b/--[no-]optimise-builtins and -i/--[no-]optimise-internals to the @kipper/cli for enabling internal and built-in functions optimisation.

Changed

• Updated error traceback generation algorithm to be more concise and useful. The algorithm will try from now on to mark the origin of the error in the source line, instead of only returning the characters causing the error.
• Updated folder structure of built-in targets, by moving all target-related files to kipper/core/src/targets. This should from now on be the folder, where all the targets that are natively supported by Kipper should be located.
• Moved all typescript-related target files to kipper/core/src/targets/typescript and split up the classes into their own files.
• Updated built-in code generation behaviour in KipperProgramContext.generateRequirements(). This function generates the built-ins for a program using its KipperTargetBuiltInGenerator, which is specified in the KipperCompileTarget.
• Fixed bug in @kipper/cli which occurred when reading files causing line endings to be internally removed. This resulted in CLI errors sometimes displaying an entire Kipper file as a single line of code, instead of displaying the original code line alone.
• Renamed:
  • builtIns to kipperRuntimeBuiltIns.
  • semantic-analyser.ts to target-semantic-analyser.ts.
  • ParserASTNode.ensureTokenChildrenExist() to getTokenChildren().
  • ParserASTNode.ensureSemanticDataExists() to getSemanticData().
  • KipperError.setMetadata() to KipperError.setTracebackData().
  • KipperAsserter to KipperSemanticsAsserter.
  • TargetTokenCodeGenerator to TargetASTNodeCodeGenerator.
  • TargetTokenSemanticAnalyser to TargetASTNodeSemanticAnalyser.
  • CompilerEvaluatedOptions to EvaluatedCompileOptions.
  • KipperProgramContext.processedParseTree to abstractSyntaxTree.
  • KipperProgramContext.builtInGlobals to builtIns.
  • CompileConfig.globals to builtIns.
  • CompileConfig.extendGlobals to extendBuiltIns.
• Optimised and simplified Kipper code generation in KipperCompileResult.write().
• Updated @kipper/core code base structure:
  • /parser/ now contains these new files:
  • ast-node.test.ts - AST Node (Previously parse-token.ts)
  • root-ast-node.test.ts - Root AST Node (Extracted from compilable-ast-node.test.ts)
  • compilable-ast-node.test.ts - Compilable AST Node (Previously compilable-parse-token.ts)
  • /semantics/language/ which contains the language specific AST Node classes that implement the semantics for the expressions, definitions and statements in Kipper.
  • /semantics/processor/ which is the module containing the Semantic analyser and Type checker.
• Updated local and global scope handling by introducing three new classes: Scope, GlobalScope and LocalScope. These classes now handle local variables and functions and implement a standard interface for handling declarations and definitions.
• Updated @kipper/cli flag names from camelCase to dash-case.

Removed

• Module kipper/core/compiler/lib, as the built-ins shall from now on be handled by each individual target instead of the whole Kipper package to allow a unique specific implementation per target.
• Deprecated errors and functions:
  • UnknownFunctionIdentifierError
  • UnknownVariableIdentifierError
  • KipperSemanticChecker.functionIsDefined
  • KipperSemanticChecker.variableIsDefined
• BuiltInFunction.handler as the core compiler will not handle code generation of Kipper built-ins (like for example print) anymore.
• Support for multi strings seperated by a whitespace (e.g. "1" "2" is counted as a single string "12"). This may be added back later, but for now it will be removed from the Kipper language.
• Error InvalidOverwriteError, as all errors it represented are now subclasses of IdentifierError.
• Unneeded functions from KipperProgramContext, as they were replaced by the new scope handling classes:
  • getGlobalFunction()
  • getGlobalIdentifier()
  • getGlobalVariable()
  • addGlobalVariable()
• Unneeded function determineScope(), as the scope handling was moved to CompilableASTNode.scope.

0.7.0 - 2022-05-22

Added

• Implemented code generation for declarations, definitions and variable assignments (#26).
• Implemented semantic analysis for AssignmentExpression and VariableDeclaration.
• Implemented support for identifiers references, which means variables can now be used in the following contexts:
  • As a function call argument: call print(identifier)
  • As a value in an arithmetic expression: identifier + identifier or identifier + 5
• Implemented CLI flag -s/--stringCode, which can be used as a replacement for the argument file. (#100). This flag is available for kipper analyse, kipper compile and kipper run)
• Implemented single char flags for the CLI (#109).
• Additional metadata and stack info when non-compiler errors are thrown during runtime in the CLI.
• New fields:
  • VariableDeclarationSemantics.value, which represents the expression that was assigned in the definition. This field is undefined if VariableDeclarationSemantics.isDefined is false.
• New functions:
  • CompileAssert.validAssignment(), which asserts that an assignment expression is valid.
  • abstract CompilableASTNode.semanticTypeChecking(), which must be implemented by every child and should serve as a separate semantic type checking step outside of primarySemanticAnalysis().
• New classes:
  • KipperAsserter, which is an abstract base class that represents a class that can be used to assert certain truths and handle/throw compile errors.
  • KipperTypeChecker and KipperSemanticChecker, which perform specialised semantic checking and verify logical integrity and cohesion. These two classes replace CompileAssert.
• New errors:
  • InvalidAssignmentError, which is thrown when an invalid assignment is used.
  • KipperInvalidInputError, which is thrown when passing invalid input to the Kipper cli.

Changed

• Optimised Kipper parsing and lexing process by updating the parsing behaviour in Kipper.g4. Kipper should handle standard expressions a lot faster from no on.
• Fixed bug #104, which caused an invalid evaluation of the return type of string additive expressions causing invalid type errors when used with other expressions.
• Fixed CLI issues with unrecognisable non-printable unicode characters, which caused errors with the Antlr4 Parser and Lexer, when reading files using the utf16le encoding.
• Fixed NULL character issue #114 when writing TypeScript code onto files using the utf16le encoding. From now on a buffer will be created using the proper encoding (also for ascii and utf8) that should be properly writable to a file.
• Fixed incomplete translation bug #118 of chained arithmetic expressions with the same operator (N + N + N) resulting in incomplete TypeScript code.
• Fixed bug #111, which caused an invalid evaluation of the return type of string expressions.
• Updated logger messages.
• Updated compiler folder structure of the core package:
  • compiler/parser from now on contains everything parser and lexer-related.
  • compiler/parser/antlr from now on contains the Antlr4 generated parser and lexer files.
  • compiler/semantics from now on contains everything semantics related, such as the file listener, the Kipper tokens, logical constants etc.
  • compiler/translation from now on contains the classes and tools used for translating Kipper code into another language.
  • compiler/targets from now on contains the existing targets for Kipper, such as typescript.
  • compiler/lib from now on contains the standard library and built-ins for Kipper.
  • compiler/lib/import from now on contains the default importable libraries for Kipper.
• Renamed:
  • Error InvalidTypeError to TypeError.
  • Function KipperProgramContext.addNewGlobalScopeEntry to addGlobalVariable().
  • Function CompoundStatement.addNewLocalVariable to addLocalVariable().

Removed

• Unnecessary traceback when encountering Kipper runtime errors as explained in #110.
• Option to use unary expressions for the left-hand side of an assignment expression in Kipper.g4. (Only identifiers may be used.)
• Option to redeclare variables. From on a variable declaration can only be done once and afterwards the variable may only be overwritten or modified, but not re-declared. This should help make Kipper have a similar behaviour to TypeScript.

0.6.1 - 2022-05-17

Added

• @types/node as a dependency for @kipper/cli.

Changed

• Updated locale dependency requirements for kipper packages to ~ (Accepting patches, but not new features). E.g. @kipper/cli requires "@kipper/core": "~0.6"

0.6.0 - 2022-05-16

Added

• Implemented TypeScript translation for constant numeric values (NumberPrimaryExpression).
• Implemented TypeScript translation for arithmetic expressions: MultiplicativeExpression and AdditiveExpression.
• New base interface ExpressionSemantics, which is the base for all expression semantics.
• New interface ArithmeticExpressionSemantics which is used as a parent for MultiplicativeExpressionSemantics and AdditiveExpressionSemantics.
• Field args in FunctionCallPostfixExpressionSemantics, which contains the Expression instances representing the arguments of a function call.
• New functions:
  • getTokenIntervalSource(), which fetches the source code for an interval of two Token instances.
  • getParseTreeSource(), which fetches the source code for a parse tree.
  • CompilableASTNode.ensureTokenChildrenExist(), which throws an UnableToDetermineMetadataError error in case that the children tokens are undefined.
  • KipperProgramContext.semanticAnalysis() (which allows for semantic analysis without compiling)
  • KipperProgramContext.translate(), which translates a processed parse tree.
  • CompileAssert.getExistingVariable() and CompileAssert.getExistingReference() for fetching reference variables based on an identifier.
  • CompoundStatement.getLocalVariable() and CompoundStatement.getVariableRecursively() for fetching a variable based on an identifier inside a CompoundStatement/KipperScope.
• New types:
  • KipperReturnType, which represents valid types that may be returned from a function.
  • KipperPrimitiveType, which represents primitive types in Kipper.
  • KipperMultiplicativeOperator, which represents multiplicative operators (*, /, ** and %).
  • KipperAdditiveOperator, which represents additive operators (+ and -).
  • KipperPlusOperator, which represents the Kipper plus operator.
  • KipperMinusOperator, which represents the Kipper minus operator.
  • KipperStrLikeTypes, which represents string-like Kipper types, like char and str.
• New errors:
  • UndefinedSemanticsError, which specifically is thrown whenever the semantics of a token are undefined.
  • UndefinedIdentifierError, which is thrown when an identifier is referenced that does not exist.
  • ArgumentError, which is thrown whenever there is an error related to invalid arguments inside a function call.
  • InvalidReturnTypeError, which is thrown whenever an invalid type is set as return type of a function.
  • InvalidAmountOfArgumentsError, which is thrown whenever an invalid amount of arguments is passed to a function.
  • InvalidArithmeticOperationError, which is thrown whenever an invalid arithmetic operation is performed.
  • KipperNotImplementedError, which is thrown when a feature is used that is not yet implemented in Kipper.
• New constants:
  • defaultWebBuiltIns and defaultNodeBuiltIns, which provide the default built-in functions for Kipper. Kipper will attempt from now on to detect whether the environment is a browser and use defaultWebBuiltIns in that case and otherwise default to defaultNodeBuiltIns.
  • kipperStorageTypes, which represents all valid storage types in Kipper.
  • kipperMultiplicativeOperators, which represents all valid multiplicative operators in Kipper.
  • kipperAdditiveOperators, which represents all valid additive operators in Kipper.
  • kipperArithmeticOperators, which combines both kipperAdditiveOperators and kipperMultiplicativeOperators.
  • kipperVoidType, which represents the Kipper void type.
  • kipperFuncType, which represents the Kipper func type.
  • kipperBoolType, which represents the Kipper bool type.
  • kipperNumType, which represents the Kipper num type.
  • kipperCharType, which represents the Kipper char type.
  • kipperStrType, which represents the Kipper str type.
  • kipperPlusOperator, which represents the Kipper plus operator.
  • kipperMinusOperator, which represents the Kipper minus operator.
  • kipperStrLikeTypes, which represents string-like Kipper types, like char and str.

Changed

• Renamed:
  • getTokenSource to getParseRuleSource, and replaced the original function with getTokenSource that only fetches the code for a single Token instance.
  • CompilableASTNode.antlrCtx to antlrRuleCtx.
  • functionIdentifierNotUsed to functionIdentifierNotDeclared.
  • variableIdentifierNotUsed to variableIdentifierNotDeclared.
  • Field name to identifier in interface BuiltInFunctionArgument.
• Deprecated the following items (Should be removed in 0.8.0):
  • variableIsDefined
  • functionIsDefined
  • UnknownVariableIdentifierError
  • UnknownFunctionIdentifierError

Removed

• Invalid expression class ArgumentExpressionListExpression and its abstract translation function in KipperTargetCodeGenerator.
• Unneeded function RootFileParseToken.compileCtx.

0.5.0 - 2022-05-11

Added

• New field target in CompileConfig, which defines the compilation target for a Kipper program.
• New field and constructor argument KipperProgramContext.target, which defines the compilation target for the program.
• New type TargetTokenSemanticAnalyser, which represents a function type that semantically analyses a CompilableASTNode.
• New type TargetTokenCodeGenerator, which represents a function type that semantically analyses a CompilableASTNode.
• Target-specific code generator KipperTargetCodeGenerator, which defines the functions that convert the Kipper code into a specific target language.
• Target-specific semantic analyser class KipperTargetSemanticAnalyser, which can define additional semantic analysis logic for a compilation target.
• Class KipperCompileTarget which defines the functions and classes for how to handle the translation to a specific target.
• Class TypeScriptTarget, which defines the default target for Kipper.
• Abstract fields targetCodeGenerator and targetSemanticAnalysis, which must be defined in child classes of abstract base class CompilableASTNode.
• New getters target, codeGenerator and semanticAnalyser in class CompilableASTNode.
• New protected functions primarySemanticAnalysis and targetSemanticAnalysis, which are split to separate the core/primary semantic analysis and the target specific semantic analysis.
• New types KipperVoidType, KipperNumType, KipperStrType, KipperCharType, KipperBoolType and KipperListType, which represent Kipper available types in the Kipper language. core/primary semantic analysis and the target specific semantic analysis.
• Assert function CompileAssert.getExistingFunction() for fetching a function and throwing an error if it does not exist.
• New CLI commands:
  • version, which returns the currently installed Kipper version.
  • update, which updates the CLI if a new version is available.
• New CLI plugins:
  • Plugin and manual command update, which updates the CLI if a new release is available.
  • Plugin warn-if-update-available, which will display a warning when the CLI is used that a new version can be installed.

Changed

• Deprecated @kipper/base as it is now replaced with @kipper/core.
• Fixed @kipper/cli bug causing logging messages to only contain "anonymous-script".
• Extracted the content of the RootFileParseToken.compileCtx function and added new two functions RootFileParseToken.semanticAnalysis(), which semantically analysis the code for basic semantics and target-specific semantics, and RootFileParseToken.translate(), which translates the code into the specific target.
• Made CompilableASTNode.semanticAnalysis() and CompilableASTNode.translateCtxAndChildren() non-abstract and implemented basic processing algorithm to run the code from CompilableASTNode.targetCodeGenerator and CompilableASTNode.targetSemanticAnalysis.
• Changed semantic definitions for CompilableASTNode children classes and created for each child class a representing semantics class defining the metadata for the token.
• Renamed error UnknownFunctionIdentifier to UnknownFunctionIdentifierError.
• Renamed function CompileAssert.assertTypeExists to typeExists.

Removed

• File CHANGELOG.md from @kipper/cli and @kipper/core, as it is now only shipped with kipper.

0.4.0 - 2022-05-03

Added

• New function KipperLogger.reportError() for reporting and logging errors.
• New function KipperAntlrErrorListener.getSourceCode() for fetching the source code for a syntax error.
• Proper tracebacks handling for KipperSyntaxError (#42).
• Getter fields line, col, filePath and tokenSrc in KipperError, which returns the metadata for the error.
• Fallback option for Lexer errors, where if offendingSymbol is undefined the entire line of code is set as tokenSrc (#36).
• Getter field KipperParseStream.lines returning all lines in the source file as an array.

Changed

• Fixed missing traceback line hinting (#24).
• Fixed missing error and fatal error logs (#34).
• Renamed function CompileAssert.error() to CompileAssert.throwError() and added error logging for the error passed as argument.
• Renamed KipperErrorListener to KipperAntlrErrorListener.
• Renamed InternalKipperError to KipperInternalError.
• Fixed usage of default antlr4 listeners for lexer errors (#36).

Removed

• Field KipperCompiler.errorListener, as due to (#42) the KipperAntlrErrorListener will have to be initialised per compilation, not per compiler instance.
• Namespace Utils and moved its methods into the global scope of the file to allow the following import scheme import * as Utils from "@kipper/core/utils", where the user can themselves define the wanted scope identifier.

0.3.0 - 2022-04-28

Added

• Implemented handling of declarations and definitions, where definitions can only appear once. ( Reassignments are not counted as definitions!)
• Traceback handling using KipperErorr.getTraceback() and KipperError.setMetadata.
• New namespace Utils with new function getTokenSource() and determineScope().
• New errors FunctionDefinitionAlreadyExistsError and VariableDefinitionAlreadyExistsError, which are raised if definition rules are violated.
• Project version information constants in index.ts.
• Implemented abstract classes to differentiate error groups: InvalidOverwriteError and IdentifierError.
• KipperInternalError, which is raised in case there is an internal error/bug.

Changed

• Renamed definition errors:
  • DuplicateVariableDefinitionError to IdentifierAlreadyUsedByVariableError
  • DuplicateFunctionDefinitionError to IdentifierAlreadyUsedByFunctionError
• Renamed antlrContext to antlrCtx across all files.
• Changed behaviour of the assert system:
  • All assertion will if possible now handled using the expression KipperProgramContext.assert(ctx).ASSERT_FUNC().
  • Assertions should happen in the semanticAnalysis() step.
  • Registrations and updates of stack information should also happen in the semanticAnalysis() step to properly compile top to bottom. (For now there is no support for calling functions that are defined afterwards in the file. So a pre-declaration is required!)
• Updated behaviour of CompilableASTNode to determine semantics and semantic types using generic classes. This means all semantic data is now stored using the get and setter CompilableASTNode.semanticData.

Removed

• Method CompilableASTNode.compileCtx() added in 0.2.0, and split the handling of the semantic analysis and compilation into two separate stages. This means that before compilation, all children will be semantically analysed. Starting from the bottom/the simplest tokens working upwards as the tokens get more complicated.
• Unneeded private tracking of _currentScope in KipperFileListener, as the scope handling system has been replaced with a dynamic determination using semanticAnalysis().

0.2.1 - 2022-04-22

Added

• Updated kipper-standalone global identifier behaviour and added support for WebWorkers.

0.2.0 - 2022-04-13

Added

• Created new class CompileAssert, which is used to assert certain compiler-required truths, which, if false, trigger corresponding errors.
• New errors UnknownVariableDefinition and UnknownFunctionDefinition.
• New getter CompilableASTNode.tokenStream, which returns the programCtx.tokenStream instance.
• Created new expression class ArgumentExpressionList representing an argument list inside function calls.
• New function KipperCompileResult.write(), which creates a human-readable string from the generated source code.
• Added new property and constructor parameter logLevel, which defines which messages should be logged. (Only messages with equal or higher importance will be logged).
• Added class name insertion for custom Kipper errors by setting the name property explicitly.

Changed

• Changed execution of most compilation functions to async.
• Replaced DuplicateIdentifierError with DuplicateVariableDefinitionError and DuplicateFunctionDefinitionError.
• Renamed NoBuiltInOverwriteError to BuiltInOverwriteError.
• Made all getMetadata functions /tokens/ instance-methods, removing all required parameters.
• Changed compilation result from Array<string> to Array<Array<string>>, where each nested array represents a line combined of string tokens.
• Set explicit children type for expressions and statements, instead of letting them inherit the children type from CompilableASTNode.
• Set return type of compileCtx to Array<string> in children classes of Expression.
  • Changed visibility of CompilableASTNode.semanticAnalysis() and CompilableASTNode.translateCtxAndChildren() to protected, as they will be replaced and tied together using CompilableASTNode.compileCtx().
• Replaced compilation in RootParseToken.translateCtxAndChildren with RootParseToken.compileCtx().
• Changed values of LogLevel to numeric values, which can be translated into strings using getLogLevelString().

Removed

• Functions RootParseToken.semanticAnalysis() and RootParseToken.translateCtxAndChildren

0.1.2 - 2022-04-06

Added

• Implemented simple scope logic by adding the scope property to all Statement classes and creating a tracking variable called _currentScope in KipperFileListener, which will be updated while processing the parse tree.
• Added variable metadata handling in VariableDeclaration. The class will now on construction determine its identifier, storage type, value type and state (whether it was defined yet) using its antlr4 context instance.
• Added errors BuiltInOverwriteError, UnableToDetermineMetadataError and UnknownTypeError.
• Added new abstract base class ScopeDeclaration, which is the parent class for the already existing ScopeDeclaration and the added ScopeFunctionDeclaration.
• Implemented KipperProgramContext.globalScope, which contains all global variables and function definitions.
• Implemented support for function definitions that will be from now on automatically registered globally.

Changed

• Renamed class ScopeDeclaration to ScopeDeclaration and updated its constructor to require a token (VariableDeclaration instance), which will automatically set the properties (identifier, storage type, value type, scope and state).
• Rearranged constructor arguments of KipperParseStream to stringContent, name, charStream, and set name to default to "anonymous-script".
• Updated CompoundStatement children behaviour, by adding a new array localScope, which will store the metadata for all variables exclusively available in that compound statement.

0.1.1 - 2022-04-01

Added

• Added missing dependency tslib

0.1.0 - 2022-04-01

Added

• KipperFileListener.itemBuffer, which will contain the generated TypeScript code-lines, that were generated in the walking step.
• Basic KipperFileContext, which will serve as the base class, where the compilation data is stored.
• General namespace import of kipper in index.ts, which allows the usage of the entire library.
• KipperFileContext.translate(), which walks through the listener and returns the generated code. The generated code will be cached inside KipperFileContext.typescriptCode to allow reusing code instead of unnecessarily generating code again.
• LogLevel.UNKNOWN as the default log level for LogLevel.
• KipperLogger.levels as a static variable to access the enum LogLevel.
• New abstract base class CompilableASTNode, which will represent the major parse tokens inside a kipper program. The token class has the additional functionality of wrapping an entire antlr4 statement, expression or block, and being able to semantically analyse it using semanticAnalysis() and translate it to TypeScript using compileCtx().
• Properties parser, lexer, errorHandler and tokenStream inside the class KipperFileContext.
• File builtIns.ts, which defines the behaviour on how to define built-in items inside a kipper program. This primarily includes global functions, which can be represented using the interface BuiltInFunction. (In work!)
• Implemented ** (Power-to) as a valid arithmetic expression.
• Implemented RuntimeCompileConfig and CompileConfig, which may be passed onto KipperCompile.compile() to configure the compilation behaviour.
• Implemented new module /compiler/tokens, which contains the parse token implementations.
• Implemented basic global function print that will be available inside a Kipper program per default (unless forcibly changed).
• New Class ScopeDeclaration representing a declaration/entry inside a scope. This is used primarily inside KipperProgramContext, which uses it to keep track of global definitions and also CompoundStatements, which may have children definitions.
• Type Implementation with two new type aliases: KipperStorageType and KipperType.

Changed

• Made return of KipperCompiler.parse() to KipperFileContext, which wraps the generated parse tree.
• Behaviour of KipperCompileResult, which will now store the programCtx: KipperFileContext and result: string[] of a compilation.
• Fixed bug in KipperErrorListener, which resulted in errors being not properly raised. The function is now a template, where <T> represents the offending token. <T> will also be passed onto KipperSyntaxError<T>.
• Changed type of LogLevel, which now returns string-representations of the log level.
• Fixed initializer rule in Kipper.g4 and removed invalid designator rules.
• Updated all expressions in Kipper.g4 to contain proper labelled sub-rules, which clearly state if the expression is used or if it's a pass on and an expression with higher importance is used (child of that expression).
• Renamed KipperFileContext to KipperProgramContext, which will now handle the entire compilation and store its meta-data.

Removed

• Unneeded namespace KipperStreams and its functions.
• Unneeded variable LogLevelNames, as now the enum LogLevel per default returns the names of the level.
• Removed preferLogging options in the entire module, as errors and warnings will always be logged no matter what. This also means that errors will always be logged and thrown as a catchable error instance.
• Argument streamName in KipperCompiler.syntaxAnalyse() and KipperCompiler.compile().

0.0.5 - 2022-03-02

Changed

• Fixed invalid publish of the module on npm

0.0.4 - 2022-03-02

Broken version!

0.0.3 - 2022-03-02

Added

• Build Option for the browser-compatible script kipper-standalone.js
• Basic run command for running a compiled file or compiling and running a file. (This is still in development).
• Basic compile command for compiling a file into it's js-counterpart with its typescript types added.
• New Parse Stream class KipperParseStream, which implements a basic Utf-16 stream.
• Support for [] initializers for lists in Kipper.g4.
• Support for multiItemTypeSpecifier, which use the identifier<T> syntax (for lists specifically).
• Support for typeof(V) (typeofTypeSpecifier) syntax for typeSpecifier expressions.
• Support for Kipper-Conversion identifier as typeSpecifier syntax.
• Support for for-loops using the for(INIT_EXPRESSION; CONDITION, LOOP_EXPRESSION) STATEMENT syntax.
• New Map LogLevelNames, which will map LogLevel enum values to constant strings (e.g. LogLevel.CRITICAL -> "CRITICAL").

Changed

• Fixed syntax bug in Kipper.g4 that caused typed arguments to not be able to passed to functions.
• Updated handling of the KipperLogger, which will now only use an emitHandler, which can be defined by the user. This means the user entirely decides how to handle the logging output of the compiler, and there is no default logging anymore.

Removed

• Oclif CLI, which will be released in another package separate to this one, as this will be made to suit the usage inside a browser.
• KipperParseFile, which will be implemented in the NodeJS CLI implementation for Kipper

0.0.2 - 2021-11-23

Added

• oclif environment with the appropriate tests
• /test/module for module specific tests using mocha
• KipperErrorListener<Token> for listening to KipperParser and KipperLexer errors
• ParserFile for implementing the stream that may be used for KipperCompiler.parser()

Changed

• Updated file structure to separate commands (for oclif) and compiler (for the compiler source-code)