apollovm 0.1.29

apollovm: ^0.1.29 copied to clipboard

• New lib/src/languages/lua/ module: ApolloParserLua, LuaGrammarDefinition/LuaGrammarLexer, ApolloCodeGeneratorLua and ApolloRunnerLua, all built on the shared AST (no AST changes).
• Grammar covers top-level and local functions, local/global variables, if/elseif/else, while, numeric and generic for ... in ipairs(...), return, expressions/operators (and/or/not, ~=, .. concatenation), table constructors (list and map), and a table-based class convention (Name = {}, Name.__index = Name, function Name:method(...)) grouped into the shared class AST. Return types are inferred (void vs dynamic).
• Generator emits idiomatic Lua: keyword-delimited blocks with end, local variables, .. string concatenation, and/or/not/~=, table literals, and self./self: prefixing inside methods.
• Registered in ApolloVM (getParser/createRunner/createCodeGenerator).
• Tests in test/apollovm_lua_test.dart cover parse+run, translate+re-execute to Dart/Lua/Kotlin, and bidirectional table-based classes.

• New lib/src/languages/kotlin/ module: ApolloParserKotlin, KotlinGrammarDefinition/KotlinGrammarLexer, ApolloCodeGeneratorKotlin and ApolloRunnerKotlin, all built on the shared AST (no AST changes).
• Grammar covers top-level and class fun declarations, val/var declarations (with type inference), Int/Double/Boolean/String/ Unit/Any/List/Map types, if/else, for (x in ...), while, expressions/operators, listOf/mapOf literals, and "$x" / "${expr}" string templates. println is normalized to the VM's print.
• Registered in ApolloVM (getParser/createRunner/createCodeGenerator); .kt files already mapped to kotlin.
• Tests in test/apollovm_kotlin_test.dart cover parse+run and Kotlin→Dart/Java/Kotlin translation round-trips.

• Parser (ApolloParserJavaScript, JavaScriptGrammarDefinition, JavaScriptGrammarLexer): parses .js/javascript source into the shared ApolloVM AST. Covers classes (fields + methods, static, constructor), top-level function declarations, let/const/var, for/for...of/while, if/else if/else, list literals, ++/--, compound assignment, strict equality (===/!==), and single/double-quoted strings plus back-tick template literals with ${ … } interpolation. Untyped sites map to dynamic; method/function return types are inferred as void (no value-return) or dynamic.
• Code generator (ApolloCodeGeneratorJavaScript): emits idiomatic modern JS from any loaded AST (Dart, Java, or JS) — let/const, template literals for string interpolation, for...of, top-level functions, untyped params/fields, ===/!==, and Math.trunc(a / b) for integer division.
• Runner (ApolloRunnerJavaScript): executes JS-parsed ASTs in the VM (subject to the VM's existing limitation that arithmetic requires concrete/inferable types — dynamic-typed arithmetic is unsupported, as for Dart dynamic).
• Registered javascript/js in ApolloVM.getParser, createRunner, and createCodeGenerator.
• CLI: apollovm run/translate now work on .js files (the .js extension already mapped to javascript); added a test/hello_world.js fixture and updated the CLI banner to "Dart, Java and JavaScript".
• Tests: added javascript_basic_* definitions (parse + execute + round-trip + cross-translation to Dart/Java) and a JavaScript generation block to the Dart class-function test.
• Follow-ups: destructuring, spread, async/await, true constructor semantics with this.x parameters, and full ESM are not yet supported.

Wasm collections — compound subscript assignment (P3, part 9):

• m[k] += v (and -=, *=, /=, ~/=) and the same for list indices a[i] += v now compile to Wasm. Lowered by desugaring c[k] OP= v into c[k] = c[k] OP v, so it reuses the existing get/set codegen and works for maps (int/String keys) and lists across int/double values. Matches the interpreter on both wasm_run and Chrome (e.g. a frequency counter can now use m[w] += 1 directly).

Wasm collections — map parameters & returns (P3, part 8):

• Functions can now accept and return whole Maps across the host boundary. The runner marshals a Dart Map into the module's map layout (header + parallel key/value buffers, via the exported __alloc) for Map parameters, and decodes a returned map-header pointer back into a Dart Map. Covers int/String keys × int/double/String/bool values, including round-tripping and returning a map built with m[k] = v.
• The apollovm_sig custom section now encodes a map type as [7, <key tag>, <value tag>], so raw-byte modules self-describe their key/value types. Element read/write was factored into shared helpers used by both list and map marshalling.

Wasm collections — map .keys / .values + iteration (P3, part 7):

• m.keys and m.values now compile to Wasm: each materializes a fresh list by copying the map's parallel key (or value) buffer (which already has the list element layout), so for (var k in m.keys) / for (var v in m.values) work via the existing list for-each. Matches the interpreter on both wasm_run and Chrome.
• The for-each loop-variable type resolver now derives the element type from the map (m.keys → key type, m.values → value type) so the loop variable is correctly typed.

Wasm collections — maps with String keys (P3, part 6):

• Map<String, V> now compiles to Wasm (V = int/double/String/bool): literals, m[k] get, m[k] = v set, .length/.isEmpty/.isNotEmpty, and .containsKey(k). Matches the interpreter on both wasm_run and Chrome.
• String keys are stored as i32 pointers and compared by content via a synthesized __streq(a, b) helper (length check + byte loop), so e.g. containsKey("app") correctly returns false for a map keyed by "apple", and multi-byte UTF-8 keys work.

Wasm collections — maps with int keys (P3, part 5):

• Map<int, V> now compiles to Wasm (V = int/double/String/bool). A map value is an i32 pointer to a 16-byte header [length][capacity][keysPtr][valuesPtr] with parallel key/value buffers; lookup/set is a linear scan with i64 key equality. Matches the interpreter on both wasm_run and Chrome.
• Supported: map literals (incl. empty {}), m[k] get, m[k] = v set (in-place update or append, growing both buffers when full), .length, .isEmpty/.isNotEmpty, and .containsKey(k).
• Also adds Wasm list index assignment a[i] = v (the subscript-assignment AST node now lowers to Wasm for both maps and lists).
• Out of scope for this slice: String keys (need a string-equality helper), .keys/.values/iteration, map parameters/returns, and compound subscript assignment (m[k] += v) — note m[k] = m[k] + 1 already works.

Dart subscript assignment — m[k] = v and a[i] = v (frontend + interpreter):

• The grammar now parses container-entry assignment targets (previously the assignment left-hand side was only a bare variable, so m[k] = v / a[i] = v failed with a SyntaxError). Compound operators (+=, -=, *=, /=, ~/=) are supported, e.g. m["x"] += 1 for building a frequency map.
• New AST node ASTExpressionVariableEntryAssignment; new ASTValue.writeKey/writeIndex write into the underlying Map/List in place. A Map is always written by key (even a numeric one); a List by index. Round-trips through the code generators (parse → regenerate → re-parse).
• Empty collection inference fix: an empty {} literal (typed Map<dynamic,dynamic>) is now assignable to a typed map such as Map<String,int> — ASTTypeMap.acceptsType treats a dynamic key/value component as a wildcard, matching how lists already ignore their element type for assignment (so Map<String,int> m = {}; works, like List<int> a = [];).

Dart Map support — frontend + interpreter (read/query; prerequisite for Wasm maps):

• Grammar fix: Map<K,V> type annotations now parse. mapTyped() was missing the value-type parser (it accepted only Map<K,> and read the , token as the value type), so every Map<int,int> declaration failed with a SyntaxError. Key/value types also accept List<...> (e.g. Map<String,List<int>>).
• Map literals now infer their key/value types from entries (mirroring list literals) instead of being hardcoded to Map<dynamic,dynamic>, so Map<int,int> m = {1:10} assigns cleanly. ASTExpressionMapLiteral.resolveType returns the Map type (it previously returned just the value type).
• Map index by key: m[k] now does a key lookup for any Map (the access was incorrectly routed to positional/list indexing whenever the key was numeric, so int-keyed maps failed).
• New core Map class (CoreClassMap): getters .length/.isEmpty/.isNotEmpty/.keys/.values and methods .containsKey/.containsValue/.remove/.clear. .keys/.values resolve to List<keyType>/List<valueType> so iterating them yields properly-typed elements.
• Maps work as function parameters.
• Note: map subscript assignment (m[k] = v) is a follow-up (the grammar's assignment target is still a bare variable).
• Functions can now accept and return whole lists across the host boundary. The runner marshals a Dart List into module memory (header + elements buffer, via the exported __alloc) for List parameters, and decodes a returned list-header pointer back into a Dart List. Covers int/double/String/bool element lists, including round-tripping (List<int> echo(List<int> a)) and building a result with .add before returning it.
• The apollovm_sig custom section now carries list types as [6, <element tag>] (was a single opaque tag), so modules loaded from raw bytes self-describe their list element types; the runner uses 64-bit element reads/writes via BigInt so it works on both the Dart VM and dart2js (Chrome).
• A String/List parameter now also forces an exported __alloc (previously only String params did), so list-only functions can be fed their arguments.

Wasm collections — String & bool element lists (P3, part 3):

• List<String> and List<bool> now compile to Wasm: literals, index reads a[i], for (var e in a), .add, and the .first/.last/.isEmpty/.isNotEmpty/.length getters all work (elements stored as i32 — a string pointer or a 0/1 boolean). Matches the interpreter on both wasm_run and Chrome.
• Maps remain a later slice.

Wasm collections — growable lists .add + getters (P3, part 2):

• List values are now an indirect handle: a 12-byte header [length:i32][capacity:i32][dataPtr:i32] pointing at a separately-allocated elements buffer. This makes .add aliasing-safe — growing reallocates the data buffer (doubling capacity, memory.copying existing elements) and updates the header in place, so existing references observe the new length/contents.
• list.add(x) now compiles to Wasm for int/double lists (including starting from an empty [] literal), growing linear memory on demand.
• New list getters compiled to Wasm: .first, .last, .isEmpty, .isNotEmpty.
• bool-returning functions loaded from raw Wasm bytes now decode correctly: the apollovm_sig custom section is emitted for bool returns (not just String signatures), and the runner maps the i32 0/1 back to a Dart bool.

Wasm collections — lists, read + iterate (P3, part 1):

• int/double list literals compile to linear-memory blocks; index reads a[i], the .length getter, and for (var e in a) now compile to Wasm (matching the interpreter, on both wasm_run and Chrome).
• Lists currently stay internal (return scalars); list parameters/returns and maps are later slices.

Wasm generator — major feature expansion (ApolloGeneratorWasm), moving toward full Dart parity:

• Loops: while and for loops now compile to Wasm (block/loop/br_if/br), including return from inside a loop. Added the br opcode helper and recursion into loop bodies when collecting function locals.
• Function calls: local function invocation (calling other top-level functions, including recursion) via a function-index table threaded through the generator and a Wasm.call.
• Operators: integer modulo % (i64.rem_s), logical &&/|| (i32.and/i32.or), logical negation ! (i32.eqz), and unary minus - (f64.neg / i64 multiply-by--1).
• Booleans: bool literals and bool-typed locals (represented as Wasm i32).
• Bug fix: the == 0 fast-path (i64.eqz) was incorrectly applied to any operator with a literal-0 right operand (e.g. x > 0 compiled as x == 0). It is now restricted to the equals operator.
• Short-circuit && / ||: now compile to an if/else so the right operand is only evaluated when needed. The AST interpreter was also made short-circuiting, so interpreted and compiled execution stay consistent (and match Dart).
• Full Dart % semantics: integer and double modulo now return the Dart-correct non-negative result in [0, |b|) for negative operands (sign-corrected via scratch locals); double % is computed as a - trunc(a / b) * b.
• Fix: compound assignment (+=, -=, *=, …) emitted its operation to a discarded buffer (missing out/context), producing broken code; now applied to the real output.

Tests: added Wasm coverage for every feature above plus a combined integration test (prime counting / sum-of-squares using loops + calls + logic + modulo), all executed against the real compiled-and-run Wasm module.

Wasm strings — String parameters + memory.grow (P2, part 5, completes the strings milestone):

• Functions taking String parameters now work: the runner encodes the Dart string into module memory (via the exported __alloc, guided by the apollovm_sig param tags) and passes the i32 pointer. Enables String echo(String s), String greet(String name), etc.
• The allocator (both the exported __alloc and the inline concat allocator) now grows linear memory on demand (memory.size/memory.grow), so large strings/concatenations no longer trap.

Wasm strings — number→string interpolation (P2, part 4):

• Interpolation of int/double ("n=$n", "${a + b}") now compiles to Wasm via host imports env.int_to_str/env.double_to_str; the host formats the number (matching the interpreter; doubles via ASTTypeDouble.doubleToString) and writes it into module memory.
• Adds a synthesized, exported __alloc bump-allocator function so host imports can allocate strings in the module's memory (reentrant host→module calls), plus value-returning host imports and i64↔BigInt marshalling on the web.

Wasm strings — String-returning functions (P2, part 3):

• Functions returning String now work: the value is an i32 pointer the runner decodes back into a Dart String.
• Modules are now self-describing: a custom apollovm_sig section records each public function's high-level return/parameter type tags, so the runner can marshal strings even for modules loaded from raw bytes. Emitted only when a public signature involves a String (pure-numeric modules stay byte-identical).

Wasm strings — concatenation + bump allocator (P2, part 2):

• A mutable heap-pointer Global ($hp) bump allocator; runtime string allocation via __alloc + memory.copy.
• String +, adjacent string literals, and $var interpolation of String variables now compile to Wasm (left-folded binary concatenation producing a fresh [len:i32][utf8] string). Validated on wasm_run and Chrome.
• Note: bump-and-leak (no free yet); number→string interpolation and string returns are later slices.

Wasm linear-memory foundation + strings (P2, part 1 — print of string literals):

• The generator now emits Import / Memory / Global / Data sections and offsets the function-index space past imported functions (a body-first two-pass build). Modules with no strings/imports remain byte-identical.
• String literals are interned into a static data segment as [len:i32][utf8]; a String value is an i32 pointer into the exported linear memory.
• print(stringLiteral) lowers to a host import env.print(i32). The runtime layer (WasmRuntime/WasmModule) now wires host imports at instantiation and exposes exported memory reads, on both the native (wasm_run) and browser runtimes; the runner decodes the pointer and routes to externalPrintFunction.
• New wasm.dart memory opcodes (i32/i64 load/store, load8_u/store8, memory.size/grow/copy/fill) and section-id helpers.

Test infrastructure — WebAssembly GC validation path:

• Established a browser (dart test -p chrome) parity harness that runs generated Wasm on Chrome's own engine. The native wasm_run backend (wasmtime 14 / wasmi 0.31) does not support the WebAssembly GC proposal; Chrome (v119+) does.
• Added a wasm-gc test tag (dart_test.yaml) and a WasmGC capability spike; CI's wasm_run-based jobs exclude the tag (--exclude-tags wasm-gc) while the Chrome job runs it. This gates the planned dual-target (linear-memory + WasmGC) backend work.

Bug fixes:

• Loop return propagation: a return inside a for, while, or for-each loop was ignored (the loop shadowed runStatus with a fresh instance and never broke on return). Returns now propagate and stop iteration correctly.
• ASTType equality: ASTTypeBool, ASTTypeString, ASTTypeObject, ASTTypeConstructorThis, ASTTypeVar, ASTTypeDynamic, ASTTypeNull, and ASTTypeVoid mistakenly checked other is ASTTypeInt, so equal instances never compared equal. Each now checks its own type.
• ASTTypeMap: building a map from a flat key/value list read from the (empty) target map instead of the input list, producing an empty map.
• Java generator (_escapeString): backslashes were not escaped, producing invalid Java string literals (e.g. "a\b" instead of "a\\b").
• ASTExpression.literalNumType returned ASTNumType.int for double literals.
• Corrected the operator symbol shown in ASTValueString/ASTValueNum comparison/equality error messages.

Tests:

• Increased line coverage from ~64.6% to ~70.9%.
• Added regression tests for all the fixes above and extensive unit/integration tests for ASTValue, ASTType, ApolloVM, expressions, the core library, and the Wasm generator.

Dependencies:

• data_serializer: ^1.2.1 -> ^1.2.2
• test: ^1.31.0 -> ^1.31.1

• Updated getTypeByName to treat 'const' as an unmodifiable variable type alongside 'final'.
• Modified classFieldDeclaration, constructorTypedParameterDeclaration, statementVariableDeclaration, and parameterDeclaration parsers to accept both final and const tokens as optional modifiers.
• Adjusted logic in statementVariableDeclaration to recognize 'const' as unmodifiable and handle it similarly to 'final'.

• generateASTExpression:
  • Fixed string template merging logic to correctly handle variable accesses and literal strings by swapping checks on expression1 and expression2.
  • Improved merging of adjacent quoted strings with different quote types by adding _tryMergeQuotedStrings and related helper methods.
  • Added robust checks for unescaped quotes inside strings to safely convert quote types.
• Added helper methods:
  • _isQuotedString, _isSingleQuoteString, _isDoubleQuoteString
  • _canConvertQuote, _convertQuote
  • _mergeQuotedStrings, _tryMergeQuotedStrings

• Refactored expression parsing to delegate expression operation precedence and logical operator handling to computeFinalExpression.

• Refactored to extend new BaseGrammarLexer abstract class.
• Moved common lexer methods and token handling to BaseGrammarLexer.
• Updated whitespace and comment parsers to static methods for reuse.

• Added as base class for grammar lexers with common token and identifier parsing.
• Added expression operation precedence handling via computeFinalExpression and reduceExpressionBlock.

• Refactored to extend BaseGrammarLexer.
• Removed duplicated token and identifier parsing code.
• Updated whitespace and comment parsers to static methods.

• Refactored expression parsing to use computeFinalExpression for operator precedence.

• Added comprehensive Dart arithmetic and logical expression tests covering operator precedence, mixed numeric types, and complex expressions.
• Updated multiple Dart and Java11 test definitions to normalize expression grouping from a + (b + c) to (a + b) + c for consistent operator associativity.
• Fixed string concatenation tests to correctly merge adjacent string literals and variables.
• Updated WASM tests to fix generated bytecode for integer operations.
• Fixed linear regression and forecast tests with corrected arithmetic expressions.
• Improved test outputs to reflect corrected expression evaluation and string concatenation results.

ASTExpressionFunctionInvocation and related classes:

• Added mixin WithCallChainFunction to support chained function invocations.
• Added field chainFunctionInvocation to hold chained calls.
• Updated function invocation methods to generate chained calls in code generation (ApolloCodeGenerator).
• Updated runtime execution to process chained function calls after the main call.

ApolloCodeGenerator:

• Refactored function invocation code to use _generateChainFunctionInvocation helper for chained calls.

Dart grammar (dart_grammar.dart):

• Updated expressionGetterAccess parser to parse and attach chained function invocations.

CoreClassPrimitive:

• Removed _functionToString field and initialization.

CoreClassString:

• Added _functionToString external class function returning self.toString().

CoreClassInt:

• Added _functionToString external class function returning self.toString().

CoreClassDouble:

• Added _functionToString external class function with custom logic:
  • If the double is an integer value, returns string with .0 suffix.
  • Otherwise, returns standard toString().

ASTExpressionVariableEntryAccess:

• Replaced _asyncTry with _run2 to improve element access with proper type casting.
• Added generic _readElement<V> method to read elements with type safety.
• Updated readIndexASTValue and readKeyASTValue to return typed ASTValue<V>.

ASTExpressionFunctionInvocation and subclasses:

• Added support for chained function invocations via new chainFunctionInvocation field.
• Updated run methods to invoke chained functions sequentially after the initial call.
• Added _callChainFunction helper to process chained calls asynchronously.
• Added ASTExpressionChainFunctionInvocation class representing chained function calls.
• Updated toString methods to include chained function calls.
• Updated constructors and parsing to support chained function invocations.

ASTExpressionObjectFunctionInvocation, ASTExpressionObjectEntryFunctionInvocation, ASTExpressionGroupFunctionInvocation:

• Updated constructors and run methods to support chained function invocations.
• Added caching of function class for performance.
• Improved error handling and function resolution with chained calls.

lib/src/apollovm_code_generator.dart:

• Updated code generator to output chained function invocations in generated code.

Grammar updates (dart_grammar.dart, java11_grammar.dart):

• Added parsing rules for chained function invocations (expressionChainFunctionInvocation).
• Updated function invocation parsers to parse and attach chained function calls.

ASTValue:

• Added generic static method fromValue<V> to convert dynamic values to typed ASTValue<V>.
• Added readIndexASTValue<V> and readKeyASTValue<V> methods returning typed ASTValue<V>.

CoreClassString:

• Added new external string functions: replaceFirst, trimLeft, trimRight, padLeft, padRight, lastIndexOf, codeUnitAt.
• Registered new functions in getFunction with case-insensitive support.

ASTClass:

• Added toString override for better debug output.

ASTExpressionVariableEntryAccess:

• Refactored run method to use nested resolveMapped calls for asynchronous handling.
• Added private helper _asyncTry to unify index/key reading logic with async support.
• Added private helper __throwReadNPE to throw detailed ApolloVMNullPointerException with stack trace on read failures.
• Improved error messages for index/key read failures including variable, index/key, size, and value details.

ASTExpressionObjectEntryFunctionInvocation:

• Added class-level documentation with code examples for usage of object entry function calls like obj[i].fx(args) and obj[key].fx(args).

ASTValue:

• Updated readKey method signature to accept nullable Object? key parameter for better null safety.

ASTValueStatic:

• Updated readKey method signature to accept nullable Object? key.

• Added _functionToString external function returning the string representation of the instance.

• Added support for the toString core function, returning the respective _functionToString.

ASTSingleLineStatementBlock:

• Added new subclass of ASTBlock that allows only a single statement.
• Overrides addStatement to enforce single statement constraint.
• Overrides toString to output the single statement without braces.

ApolloCodeGenerator:

• Added support for ASTSingleLineStatementBlock in generateASTNode dispatch.
• Added generateASTSingleLineStatementBlock method to generate single-line statement blocks.
• Updated generateASTBlock to delegate to generateASTSingleLineStatementBlock if block is single-line.
• Updated generateASTBranchIfBlock to generate single-line blocks without braces.

ApolloGenerator:

• Added abstract method generateASTSingleLineStatementBlock.
• Added support for ASTSingleLineStatementBlock in generateASTNode dispatch.

ApolloGeneratorWasm:

• Implemented generateASTSingleLineStatementBlock to generate the single statement.

Dart and Java11 grammars:

• Added ASTSingleLineStatementBlock parsing support.
• Added codeBlockOrSingleLineBlock parser to accept either a block or a single-line block.
• Updated branchIfBlock parser to accept single-line blocks as branch bodies.

Added new AST statement classes:

• ASTStatementBlock representing a block of statements.
• ASTStatementFunctionDeclaration representing a function declaration statement.

ApolloCodeGenerator:

• Added support for generating code for ASTStatementFunctionDeclaration and ASTStatementBlock.
• Added methods generateASTStatementFunctionDeclaration and generateASTStatementBlock.

ApolloGenerator interface:

• Added abstract methods generateASTStatementFunctionDeclaration and generateASTStatementBlock.
• Updated statement dispatch to handle ASTStatementFunctionDeclaration and ASTStatementBlock.

ApolloGeneratorWasm:

• Added generateASTStatementBlock implementation.
• Added stub for generateASTStatementFunctionDeclaration (throws UnimplementedError).

apollovm_ast_statement.dart:

• Added ASTStatementBlock class wrapping an ASTBlock with proper context and run behavior.
• Added ASTStatementFunctionDeclaration class wrapping an ASTFunctionDeclaration with run behavior registering the function in the context.

apollovm_ast_toplevel.dart:

• Extended ASTFunctionDeclaration with:
  • toASTValueFunction method to convert to ASTValueFunction.
  • toFunction method to convert to a Dart Function with limited support for zero or one positional parameter.
  • resolveFunctionType and callFunctionTyped helpers for function type resolution and invocation.

apollovm_ast_type.dart:

• Added ASTTypeFunction representing function types with optional return type and parameters.
• Added callCasted helper method for generic type casting.

apollovm_ast_value.dart:

• Added ASTValueFunction wrapping a Dart Function with proper type and invocation support.
• Implemented equality, hashCode, and string representation for ASTValueFunction.

apollovm_utils.dart:

• Added resolveGeneric<T>() helper function for generic type resolution.

dart_grammar.dart:

• Extended grammar to parse function declarations as top-level definitions and statements.
• Added parsing support for ASTStatementFunctionDeclaration and ASTStatementBlock.
• Allowed optional return type in function declarations.
• Updated statement parser to include function declarations and blocks.

ASTExpressionObjectEntryFunctionInvocation:

• Added new AST expression class to represent calls to class object entry functions.
• Implements function resolution and invocation on class instances or static context.
• Overrides run and toString methods for execution and debugging.

ApolloCodeGenerator:

• Added support for generating code for ASTExpressionObjectEntryFunctionInvocation.
• Updated generateASTExpression method to handle ASTExpressionObjectEntryFunctionInvocation.

ApolloGenerator interface:

• Added abstract method generateASTExpressionObjectEntryFunctionInvocation.

ApolloGeneratorWasm:

• Added stub implementation for generateASTExpressionObjectEntryFunctionInvocation throwing UnimplementedError.

Dart and Java11 grammars:

• Added parsing rule expressionObjectEntryFunctionInvocation to support syntax for object entry function invocation expressions.

• Made sealed class.
• Added importManager field and import method to support import resolution and delegation to parent contexts.
• Updated function and external function lookup to consider imported functions.

• New AST node to represent import statements.
• Supports running import in a context, throwing on failure.

• Supports tracking and running import statements.
• Considers imported functions in function resolution.

• Added importManager field and initialization with default import manager.
• Supports auto-import of dart:math core package.
• Passes importManager to execution and function lookup calls.

• Added path getter for core package identification.

• Added support for generating import statements (ASTStatementImport).

• Added parsing of import statements into ASTStatementImport.

• Added support for auto-import-dart-math attribute in test XML.
• Tests updated to import dart:math and use pow function.

• Updated to use VMScopeContext instead of base VMContext for nested scopes.
• Updated VMObject field value methods to use VMScopeContext.

• Changed type of finalExpressionOp from ASTExpressionOperation? to ASTExpression?.
• Updated cast of expressionOp from ASTExpressionOperation to ASTExpression.

ApolloCodeGenerator:

• generateASTValueDouble: replaced manual double string formatting with ASTTypeDouble.doubleToString for consistent double string representation.

ASTStatementVariableDeclaration:

• _runImpl2: updated type cast check to allow dynamic type to bypass cast validation.

ASTTypeDouble:

• Added static method doubleToString to format double values consistently, optionally allowing scientific notation.
• Updated toString method of ASTTypeNum to return 'num' instead of 'double'.

ASTValueAsString and ASTValuesListAsString:

• Updated string conversion to use valueToString method that formats doubles using ASTTypeDouble.doubleToString.

CorePackageMath:

• Updated math function external static function wrappers to explicitly type parameters as num and return ASTTypeDouble.instance for functions returning double values.

Test framework (apollovm_languages_test_definition.dart):

• Moved output printing before output assertion in _testCall for clearer test logs.

• Updated generateASTExpression to handle ASTExpressionNegative and ASTExpressionGroupFunctionInvocation.
• Added methods generateASTExpressionNegative and generateASTExpressionGroupFunctionInvocation.
• Refactored function invocation code into private _generateFunctionInvocation helper.

• Added abstract methods generateASTExpressionNegative and generateASTExpressionGroupFunctionInvocation.
• Updated generateASTExpression to support new expression types.

• Added implementation of ASTExpressionNegative with type resolution, runtime evaluation, and string representation.
• Added implementation of ASTExpressionGroupFunctionInvocation with function resolution and invocation logic.

• Added parsing support for unary negative expressions (-expr).
• Added parsing support for group function invocations (e.g., (expr).func(args)).

• Added stub implementations for generateASTExpressionNegative and generateASTExpressionGroupFunctionInvocation.
• Updated expression generation dispatch to handle new expression types.

ASTStatementWhileLoop:

• Added new AST node class representing a while loop statement.
• Implemented run method to execute the loop with proper context handling.
• Added type resolution returning ASTTypeVoid.instance.
• Added children and node resolution methods.

ApolloCodeGenerator:

• Added support for generating code for ASTStatementWhileLoop in generateASTStatement.
• Implemented generateASTStatementWhileLoop method to generate while loop source code.

ApolloGenerator:

• Added abstract method generateASTStatementWhileLoop.
• Added dispatch for ASTStatementWhileLoop in generateASTStatement.

DartGrammarDefinition:

• Added statementWhileLoop parser to parse while loop statements.
• Integrated statementWhileLoop into the main statement parser.

Java11GrammarDefinition:

• Added statementWhileLoop parser to parse while loop statements.
• Integrated statementWhileLoop into the main statement parser.

ApolloGeneratorWasm:

• Added stub for generateASTStatementWhileLoop method throwing UnimplementedError.
• Added dispatch for ASTStatementWhileLoop in generateASTStatement.

Tests:

• Added new test dart_basic_printFibonacci.test.xml demonstrating while loop usage in Dart source and generated code.

ASTInvocableDeclaration:

• Replaced ASTFunctionDeclaration with generic ASTInvocableDeclaration for function and constructor declarations.
• Added ASTClassConstructorDeclaration for class constructors with support for this parameters.
• Added resolveRuntimeType method to support runtime type resolution with context and node.
• Updated call and run methods to support async and context-aware execution.
• Added initializeVariables for constructor variable initialization.

ASTParametersDeclaration:

• Made generic over parameter type P.
• Added ASTConstructorParametersDeclaration and ASTFunctionParametersDeclaration subclasses.
• Updated parameter accessors and type checks to use generic parameter type.

ASTParameterDeclaration:

• Added ASTConstructorParameterDeclaration with thisParameter flag.
• Added extensions for filtering this parameters.

ASTFunctionSet and ASTConstructorSet:

• Introduced generic base ASTInvokableSet with single and multiple implementations.
• Added ASTConstructorSet for constructors, similar to function sets.

ASTClassNormal:

• Added support for constructors with ASTConstructorSet.
• Added methods to add, get, and check constructors by name and signature.
• Updated resolveNode to resolve constructors.

ASTRoot:

• Updated getFunction to return constructors if matching class name and signature.

ASTExpression and ASTValue:

• Added resolveRuntimeType and getHashcodeValue methods for runtime type and value hashing.
• Updated equality and hashCode to use getHashcodeValue.

ASTExpressionFunctionInvocation and subclasses:

• Updated to use ASTInvocableDeclaration for function retrieval.
• Updated run method to support async and context-aware invocation.

ASTExpressionObjectGetterAccess:

• Updated getter retrieval and runtime type resolution to support async and context-aware evaluation.
• Added _runGetter helper for getter invocation.

ASTStatementVariableDeclaration:

• Added unmodifiable flag.
• Updated type resolution and run implementation to use resolveRuntimeType.

ASTType:

• Added ASTTypeConstructorThis singleton for constructor this parameter.
• Added resolveRuntimeType method.

ASTVariable:

• Added resolveRuntimeType method.

CorePackageBase and CoreClassMixin:

• Updated external function and class function creation to use ASTFunctionParametersDeclaration.

CoreClassList:

• Added first and last getters with runtime component type resolution.
• Added empty constructor list and related methods.

DartGrammarDefinition and Java11GrammarDefinition:

• Added parsing support for class constructors with parameters and optional blocks.
• Updated function and constructor parameter parsing to use ASTFunctionParametersDeclaration and ASTConstructorParametersDeclaration.
• Added parsing for this constructor parameters.

ApolloCodeGeneratorDart and ApolloCodeGeneratorJava11:

• Added generateASTClassConstructorDeclaration method to generate constructor code.
• Updated function parameter generation to use generic parameter declaration.

ApolloParserWasm:

• Updated WASM function parsing to use ASTFunctionParametersDeclaration.

Test:

• Added new test dart_basic_linearRegression.test.xml with Dart source for linear regression and forecast.
• Added new test dart_basic_calculateShippingCost.test.xml for shipping cost calculation.
• Updated test runner to include new tests.

ASTValueNum:

• from method:
  • Added optional asDouble parameter to control numeric type coercion.
  • Improved parsing logic to preserve numeric intent from strings containing decimal points or exponents by forcing double representation.
  • Added error handling for unsupported input types when asDouble is specified.

Added ASTExpressionNullValue class to represent null literal expressions.

ASTScopeVariable:

• Special handling for variable named 'null' to resolve as ASTValueNull.

ApolloCodeGenerator:

• Added generateASTExpressionNullValue method to generate code for null expressions.
• Updated generateASTExpression to handle ASTExpressionNullValue.
• generateASTValueDouble:
  • Fixed formatting of double values to ensure consistent decimal representation.
  • Added handling to convert scientific notation doubles to fixed decimal format with appropriate fraction digits.
• Added helper method fractionDigitsFromScientificNotation to determine the number of fraction digits needed for doubles in scientific notation.

ApolloGenerator interface:

• Added generateASTExpressionNullValue method.
• Updated generateASTExpression to handle ASTExpressionNullValue.

ApolloRunner:

• Added optional importCorePackageMath parameter to constructor and createRunner method.
• When importCorePackageMath is true, maps math functions from CorePackageMath to external functions.

CorePackageMath:

• New core package providing Dart dart:math functions as external functions for ApolloVM.
• Includes pow, sqrt, sin, cos, tan, asin, acos, atan, atan2, log, exp, abs, min, max.

Language grammars (dart, java11):

• Added parsing support for null literal expressions producing ASTExpressionNullValue.

Language runners (dart, java11, wasm):

• Added support for importCorePackageMath parameter in constructors.

ApolloGeneratorWasm:

• Added stub for generateASTExpressionNullValue throwing UnimplementedError.
• Updated generateASTExpression to handle ASTExpressionNullValue.

Test framework:

• Added new test dart_basic_stdv.test.xml demonstrating usage of math functions (pow, sqrt) and null checks.
• Updated test runner to create runners with importCorePackageMath: true to enable math functions in tests.

• Added new operator divideAsInt with symbol '~/'.
• Updated asASTExpressionOperator getter to support divideAsInt.
• Updated getASTAssignmentOperator and getASTAssignmentOperatorText to handle divideAsInt and its assignment form '~/='.

• Added support for divideAsInt operator in evaluation and string representation.

• Extended assigmentOperator parser to recognize '~/=' operator.

• No changes for divideAsInt operator (remains unsupported).

ASTExpressionListLiteral:

• resolveType: updated to return ASTTypeArray of the specified type or deduced common element type.
• children: fixed to include type correctly.

ASTStatementVariableDeclaration:

• Constructor enhanced to handle ASTExpressionListLiteral values with type adjustments or cast exceptions.

ASTStatementForEach:

• Added variableType field.
• Constructor updated to accept variableType.

ASTType:

• Added commonType method to find common compatible type between two types.

ASTTypeArray:

• toValue: improved to cast ASTValueArray to correct generic type if needed.

ASTValueArray:

• Added cast method to convert to another generic type with optional component type.

Dart grammar (dart_grammar.dart):

• statementForEach parser updated to parse explicit variable type before variable name.
• expressionListLiteral parser updated to infer common element type if not specified.

Java11 grammar (java11_grammar.dart):

• statementForEach parser updated to parse explicit variable type before variable name.

Tests:

• Added Dart test for findMax(List<int> numbers) function with multiple test cases including empty list handling.

ASTStatementForEach:

• Added new AST statement class representing a for-each loop with a variable name, iterable expression, and loop block.
• Implements run method to iterate over an iterable AST value, declaring the loop variable in a nested context and running the loop block.
• Resolves type as void.

ApolloCodeGenerator:

• Added support for generating code for ASTStatementForEach in generateASTStatement.
• Implemented generateASTStatementForEach method to output a for-in loop syntax with variable declaration and loop block.

ApolloGenerator:

• Added abstract method generateASTStatementForEach.
• Updated generateASTStatement to dispatch to generateASTStatementForEach for ASTStatementForEach.

Dart language grammar (dart_grammar.dart):

• Added parser statementForEach to parse Dart-style for-each loops (for (var x in iterable) { ... }).
• Added helper parser _forEachVariableDecl to parse optional var or final before variable name.

Java language grammar (java11_grammar.dart):

• Added parser statementForEach to parse Java-style for-each loops (for (Type var : iterable) { ... }).

CI:

• .github/workflows/dart.yml: updated actions/checkout from v3 to v6 and codecov/codecov-action from v3 to v5.

apollovm.dart:

• Exported new utility file src/apollovm_utils.dart.

apollovm_runner.dart:

• ApolloRunner:
  • executeClassMethod: changed to async, added parameter normalization before execution.
  • Added normalizeParameters method to normalize positional and named parameters against AST function declarations.
  • executeFunction: added parameter normalization for top-level functions.
  • Improved parameter handling for function execution.

apollovm_utils.dart (new):

• Added utilities for generic typed list conversion and case-insensitive map key lookup.
• Extensions on List for typed list creation and on Map for case-insensitive key lookup.

apollovm_ast_toplevel.dart:

• ASTFunctionDeclaration:
  • Added normalizeParameters, normalizePositionalParameters, and normalizeNamedParameters methods to convert and normalize parameters according to function declarations.
• Added extension IterableASTFunctionDeclarationExtension with resolveBestMatchBySignature to select best matching function overload by parameter signature.

apollovm_ast_type.dart:

• ASTType:
  • Added fromType factory to create ASTType from Dart Type.
  • Added toASTValue method to convert native values to ASTValue according to type.
• Added toASTValue overrides in primitive and collection types (ASTTypeBool, ASTTypeNum, ASTTypeInt, ASTTypeDouble, ASTTypeString, ASTTypeNull, ASTTypeVoid, ASTTypeArray, ASTTypeArray2D, ASTTypeMap, ASTTypeFuture).
• Added static fromType methods for ASTTypeArray and ASTTypeMap to create instances from Dart generic types.
• ASTTypeArray and CoreClassList:
  • Added typed singleton instances for common generic types (e.g., List<String>, List<int>, etc.).
  • Added factory constructors and fromType methods to resolve types generically.
• ASTTypeMap:
  • Added fromType method for common map generic types.
• ASTTypeFuture:
  • Added toASTValue override to handle conversion from native or future values.

apollovm_ast_value.dart:

• ASTValue.from factory:
  • Added support for ASTTypeBool to create ASTValueBool.

apollovm_core_base.dart:

• ApolloVMCore.getClass:
  • Added optional generics parameter.
  • List class resolution now uses CoreClassList.fromType with generic type.
• CoreClassList:
  • Converted to generic class CoreClassList<T>.
  • Added typed singleton instances for common generic types.
  • Added fromType static method to resolve generic list classes.
  • Constructor updated to accept generic type and resolve ASTTypeArray accordingly.

wasm_runner.dart:

• ApolloRunnerWasm:
  • Added parameter normalization before calling Wasm functions.

wasm_runtime.dart:

• Added ensureBooted() method and lastBootError getter to WasmRuntime interface.

wasm_runtime_dart_html.dart, wasm_runtime_generic.dart, wasm_runtime_web.dart:

• Implemented ensureBooted() as no-op and lastBootError as null.

wasm_runtime_io.dart:

• Added boot logic with error capture.
• Implemented ensureBooted() to call boot.
• Added lastBootError getter.

Tests (apollovm_languages_test_definition.dart):

• Updated _parseJsonList to return untyped List without generic type conversion.
• Removed redundant generic list conversion helpers from test file.
• Updated tests to call .toListOfType() extension for typed list checks.

Tests (apollovm_wasm_test.dart):

• Added call to wasmRuntime.ensureBooted() before checking support.
• On unsupported runtime, print last boot error for diagnostics.

Added support for external getters in ApolloVM:

• New class ApolloExternalGetterMapper to map Dart getters to ApolloVM.
• Added getGetter and getMappedExternalGetter methods in VMContext for getter resolution.
• Extended ASTBlock with getter management (addGetter, getGetter, etc.).
• Added ASTGetterDeclaration and related classes (ASTClassGetterDeclaration, ASTExternalGetter, ASTExternalClassGetter) to represent getters in the AST.
• Added ASTExpressionGetterAccess base class and subclasses ASTExpressionLocalGetterAccess and ASTExpressionObjectGetterAccess for getter expressions.
• Updated DartGrammarDefinition to parse getter access expressions.
• Updated ApolloCodeGenerator and ApolloGenerator interfaces and implementations to generate code for getter access expressions.
• Added externalGetterMapper field to VMContext to support external getter mapping.

Core library updates:

• Added CoreClassList class implementing core List type support with external class functions and getters for common list operations (add, remove, length, isEmpty, sublist, etc.).
• Refactored core class base and primitive classes to use CoreClassMixin for external function and getter creation.

ASTExpressionOperator:

• Added new operators: remainder, and, or.
• Updated getASTExpressionOperator and getASTExpressionOperatorText to support %, &&, and ||.

ASTExpressionOperation:

• Updated resolveType to handle remainder, and, and or operators.
• Added evaluation methods:
  • operatorRemainder for % operator supporting int and double operands.
  • operatorAnd and operatorOr for logical && and || with boolean coercion.
• Added private helper _toBoolean to convert various ASTValue types to boolean.
• Updated throwOperationError to handle new operators.

ASTValue and subclasses:

• Added % operator support in ASTValueNum, ASTValueInt, and ASTValueDouble.
• Fixed incorrect error messages in base ASTValue operator overrides.
• Added operator ~/(ASTValue other) implementations in ASTValueInt and ASTValueDouble.
• Updated operator return types for numeric operations to be more specific (ASTValueNum).

DartGrammarDefinition:

• Extended expressionOperator parser to recognize %, &&, and ||.
• Updated expression parsing logic to:
  • Split expressions into blocks separated by logical operators && and ||.
  • Resolve % operator with higher precedence within blocks.
  • Correctly build AST for logical expressions combining blocks with && and ||.

WasmGenerator:

• Added default case throwing UnsupportedError for unsupported operators in WASM code generation.

ASTTypeVar:

• Added unmodifiable field to distinguish var and final types.
• Added static instance instanceUnmodifiable for final.
• Updated constructor to accept unmodifiable flag and set name accordingly.
• Updated toString and equality to reflect unmodifiable state.

ApolloVMCore:

• Added support for double and Double core classes returning CoreClassDouble.

CoreClassPrimitive:

• Added helper _externalClassFunctionArgs2 for external class functions with two parameters.

CoreClassString:

• Added many new external class functions:
  • length, isEmpty, isNotEmpty
  • substring, indexOf, startsWith, endsWith
  • trim, split, replaceAll
• Updated getFunction to support these new string functions.

CoreClassInt:

• Added external static function tryParse.
• Added external class functions:
  • compareTo, abs, sign, clamp, remainder, toRadixString, toDouble
• Updated getFunction to support new int functions.

Added new class CoreClassDouble:

• External static functions: parseDouble (alias parse), tryParse, valueOf.
• External class functions: compareTo, abs, sign, clamp, remainder, toStringAsFixed, toStringAsExponential, toStringAsPrecision, toInt, round, floor, ceil, truncate.
• Implements getFunction to provide these functions.

ApolloCodeGeneratorDart:

• Improved string literal concatenation handling:
  • Added support for concatenating multiple string literals including raw and multiline strings.
  • Added helper writeAllStrings to write concatenated string parts correctly.
  • Improved splitting and merging of string literal blocks to avoid unnecessary concatenations.
  • Preserves multiline string formatting and raw string prefixes.

DartGrammarDefinition:

• Added support for final keyword returning ASTTypeVar(unmodifiable: true).
• Updated literalString parser to support concatenation of multiple string literals into ASTValueStringConcatenation.

Java11GrammarDefinition:

• Added support for final keyword returning ASTTypeVar(unmodifiable: true).

DartGrammarDefinition:

• getTypeByName: added support for Dart types void and bool.

DartGrammarLexer:

• stringContentQuotedLexicalTokenEscaped: added handling of unnecessary escape sequences for characters (, ), {, }, and space in string literals.

Tests:

• Added dart_basic_sumOrDouble.test.xml with a test for a Dart function sumOrDouble.
• Added dart_basic_main_print_multi_line.test.xml testing multi-line string printing.
• Added dart_basic_main_print_unnecessary_escape.test.xml testing string literals with unnecessary escape sequences and ASCII art printing.

ApolloCodeGenerator and ApolloCodeGeneratorDart:

• generateASTExpressionOperation: updated to conditionally group complex expressions with parentheses based on operator and presence of literal strings to improve expression formatting and string interpolation merging.
• Improved string concatenation merging for add operator when involving variables and literal strings.

ASTExpression and subclasses (ASTExpressionOperation, ASTExpressionVariableAssignment, ASTExpressionVariableDirectOperation, ASTExpressionNegation, ASTExpressionFunctionInvocation, etc.):

• Added isComplex getter to distinguish complex expressions.
• Added hasLiteralString and hasDescendantLiteralString to detect literal strings in expression trees.
• Updated toString methods to support optional grouping with parentheses for clarity.
• Updated ASTExpressionOperation.toString to optionally wrap expressions in parentheses.
• Updated ASTExpressionVariableAssignment and ASTExpressionVariableDirectOperation to provide detailed toString implementations reflecting operators.
• Added childrenOperations and descendantChildrenOperations helpers for expression traversal.

ASTAssignmentOperator enum:

• Added symbol field for operator symbol representation.

lib/apollovm.dart:

• Added library-level documentation describing ApolloVM as a portable VM supporting Dart, Java, and WebAssembly compilation.
• Changed library apollovm; to a library directive without a name.

AST classes (lib/src/ast/):

• Updated children getters to use null-aware spread operators (...? and ?) for optional fields in:
  • ASTExpressionListLiteral
  • ASTExpressionMapLiteral
  • ASTStatementVariableDeclaration
  • ASTBranchIfElseBlock
  • ASTBranchIfElseIfsElseBlock
  • ASTType
  • ASTTypeGenericVariable

pubspec.yaml:

• Updated dependencies:
  • petitparser from ^6.1.0 to ^7.0.2
  • lints from ^3.0.0 to ^6.1.0
  • dependency_validator from ^3.2.3 to ^5.0.5
  • xml from ^6.5.0 to ^6.6.1

Tests (test/apollovm_languages_extended_test.dart, test/apollovm_version_test.dart):

• Added library; directive at the top of test files for consistency.

WasmRuntime:

• Added WasmModuleFunction typedef to represent a WebAssembly-exported function with metadata including the Dart function and a varArgs flag.
• Updated WasmModule.getFunction signature to return WasmModuleFunction<F>? instead of just F?.

WasmRunnerWasm:

• Updated function invocation logic in ApolloRunnerWasm to handle WasmModuleFunction with varArgs flag.
• Added special handling for functions with no arguments and functions expecting a single List argument.

wasm_runtime_generic.dart:

• Updated WasmModuleGeneric.getFunction to return null as WasmModuleFunction<F>?.

wasm_runtime_io.dart:

• Updated WasmModuleIO.getFunction to return a WasmModuleFunction with varArgs: true.

wasm_runtime_dart_html.dart:

• Deprecated WasmRuntimeDartHTML in favor of WasmRuntimeWeb.
• Updated WasmModuleBrowser.getFunction to return a WasmModuleFunction with varArgs: true.
• Updated createWasmRuntime to return WasmRuntimeDartHTML with deprecation warning.

wasm_runtime_web.dart:

• New WasmRuntimeWeb implementation using dart:js_interop and web package.
• Added JS interop bindings for WebAssembly APIs using extension types.
• Implemented WasmModuleBrowser wrapping _WasmInstance with proper JS interop.
• getFunction returns a Dart function wrapping JS function calls with argument conversion and varArgs: false.
• Added utilities to convert JS BigInt to Dart num or BigInt.
• Updated createWasmRuntime to return WasmRuntimeWeb.
• Added extensions for JS function invocation and JSAny type checks and casts.

pubspec.yaml:

• Added dependency on web: ^1.1.1.

Tests:

• Added new tests operation3 and operation4 verifying multi-parameter Dart functions compiled to Wasm and executed correctly.

Updated minimum Dart SDK constraint to >=3.10.0 <4.0.0.

Dependency updates:

• swiss_knife: ^3.3.14
• async_extension: ^1.2.22
• data_serializer: ^1.2.1
• petitparser: ^6.1.0
• collection: ^1.19.1
• args: ^2.7.0
• wasm_run: ^0.1.0+2
• crypto: ^3.0.7
• path: ^1.9.1
• test: ^1.31.0

Reformatted code for Dart 3.10+

lib/src/languages/wasm/wasm_runtime_browser.dart

• Suppress deprecated dart:html usage warning with // ignore: deprecated_member_use import directive

New ASTExpressionVariableDirectOperation (++ and -- operators).

New StrictType interface for equalsStrict over ASTTypeInt and ASTTypeDouble.

ApolloGeneratorWasm:

• Improve auto casting to int32/int64 and float32/float64.
• Implemented generateASTExpressionVariableDirectOperation.

sdk: '>=3.3.0 <4.0.0'

swiss_knife: ^3.2.0

data_serializer: ^1.1.0

petitparser: ^6.0.2

path: ^1.9.0

lints: ^3.0.0

dependency_validator: ^3.2.3

test: ^1.25.2

xml: ^6.5.0

• acceptsType: now also accepts an ASTTypeInt.

• Fix isBits64.

ASTNode:

• Now is a mixin.
• getNodeIdentifier: added optional parameter requester.
• Added children and descendantChildren.

ASTFunctionDeclaration:

• getNodeIdentifier: now can also resolve identifiers inside statements.

Wasm:

• Encode function names with UTF-8.
• Wasm64: added i64WrapToi32.

WasmContext:

• Added returns state.

ApolloGeneratorWasm:

• Added _autoConvertStackTypes.
• generateASTStatementReturnValue and generateASTStatementReturnVariable:
  • Auto cast returning types.

Dart CI: added job test_exe.

ASTBranchIfElseBlock and ASTBranchIfElseIfsElseBlock:

• blockElse: optional.

ASTParametersDeclaration:

• Added allParameters.

ASTTypeInt and ASTTypeDouble:

• Added bits
• Added ASTTypeInt.instance32 and ASTTypeInt.instance64.
• Added ASTTypeDouble.instance32 and ASTTypeDouble.instance64.

ASTValueNum:

• Added field negative.

ApolloGeneratorWasm:

• Changed to 64 bits.
• Wasm: split in Wasm32 and Wasm64 with improved opcodes.
• Allow operations with different types (auto casting).
• Handle unreachable end of function cases.
• Implemented:
  • generateASTValue, generateASTValueDouble, generateASTValueInt.
  • generateASTExpressionVariableAssignment, generateASTStatementExpression
  • generateASTBranchIfBlock, generateASTBranchIfElseBlock, generateASTBranchIfElseIfsElseBlock.
  • generateASTStatementReturnWithExpression, generateASTStatementReturn, generateASTStatementReturnValue.

ApolloParserWasm:

• Identify if an ASTTypeInt or ASTTypeDouble type is a 32 or 64 bits.

ApolloRunnerWasm:

• Use the parsed Wasm functions (AST) to normalize the parameters before calling the Wasm function.

WasmModule:

• Added resolveReturnedValue.
  • Browser implementation: when the function returns a f64, the JS bigint needs to be converted to a Dart BigInt.

New WasmModuleExecutionError.

• getFunctionCodeUnit: fix returned codeUnit when allowClassMethod = true.

New SourceCodeUnit and BinaryCodeUnit.

• CodeUnit now is abstract:
  • Renamed field source to code.

Using SourceCodeUnit instead of CodeUnit when necessary.

ApolloParser renamed to ApolloCodeParser:

• Allows binary code parsing (not only strings).
• New ApolloSourceCodeParser.

ApolloRunner:

• Added getFunctionCodeUnit.

Using Leb128 from package data_serializer.

BytesOutput now extends BytesEmitter (from data_serializer).

ApolloGeneratorWasm:

• generateASTExpressionOperation: allow operations with different types (auto casting from int to double).

New WasmRuntime and WasmModule.

• Implementation: WasmRuntimeBrowser.

New WasmModuleLoadError.

WasmContext:

• Added stack status to help code generation.

data_serializer: ^1.0.11

wasm_interop: ^2.0.1

crypto: ^3.0.3

path: ^1.8.3

New ApolloGeneratorWasm.

• Basic support to compile the AST tree to Wasm.

New BytesOutput for binary code generation.

data_serializer: ^1.0.10

• Changes some StateError while executing to ApolloVMRuntimeError.

• Implementations:
  • ApolloSourceCodeStorage, ApolloSourceCodeStorageMemory.
  • ApolloBinaryCodeStorage, ApolloBinaryCodeStorageMemory.
  • ApolloGenericCodeStorageMemory.

• Added issue_tracker
• Added topics.
• Added screenshots.

• Added Codecov badge and link.

• generateASTValueStringExpression: try to preserve single quotes in concatenations sequence.

• Added support for ArrayList and HashMap literals.

• Added getClassWithMethod.

• Added getCodeUnitWithClassMethod.

• executeFunction: added parameter allowClassMethod.

• Support in dart and java grammar.

• loadCodeUnit now throws a SyntaxError with extended details.

• Added fields codeUnit, errorPosition and errorLineAndColumn.
• Added getters errorLine and errorMessageExtended

• Added support for dart and java11.

• Implement toString with a pseudo-code version of the node to facilitate debugging.

Dart CI: update and optimize jobs.

sdk: '>=3.0.0 <4.0.0'

swiss_knife: ^3.1.5

async_extension: ^1.2.5

petitparser: ^6.0.1

collection: ^1.18.0

args: ^2.4.2

lints: ^2.1.1

test: ^1.24.6

xml: ^6.4.2

path: ^1.8.3

• Added browser tests.

• Removed internal extensions with similar functionality.

• Implementing portable int class for dart and java11:
  • parse, parseInt.

• Correctly normalize int and Integer for dart and java11.

• Implementing portable String class for dart and java11:
  • Mapping: contains, toUpperCase, toLowerCase, valueOf.

• Avoid instantiation of Future, using FutureOrExtension and ListFutureOrExtension:
  • resolve, resolveMapped and resolveAllMapped.

• Strong types.
  • var types can be resolved.
  • ASTTypedNode: nodes can be typed, and resolution is performed and cached while running.
• Optimize resolution of functions.

• Dart & Java:
  • var types to be resolved at runtime.

• Dart & Java:
  • Improve String concatenation with variables.

• Dart & Java:
  • Added for loop statement: ASTStatementForLoop.

• parseLanguageFromFilePathExtension

• tryExecuteFunction
• tryExecuteClassFunction

• apollovm

• setField, getField, getFunctionWithName, getFunction,getClass

• Now they use named parameters for positionalParameters and namedParameters.

• Java & Dart:
  • Parse boolean literal.

• Better formatting for classes and methods.

• Dart:
  • Fix parsing of function with multiple parameters.
• Java:
  • Class fields.
  • Fix parsing of function with multiple parameters.
  • Return statements ;

• Dart & Java11:
  • Fix parsing of multiple parameters.

• Fix division with double and int.

• Dart & Java11:
  • Fix variable assigment duplicated ';'.
• Dart:
  • Improve string template regeneration, specially when parsed code comes from Java.

• ASTClassFunctionDeclaration: To ensure that any class function is parsed from a class block and also ensure that is running from a class block.

• Dart:
  • Fix non class function: due static modifier.
• Java:
  • Will throw an exception if the generation of a function without a class is attempted.

• Fix class object instance context.

• Dart & Java:
  • Class fields.
  • Class object instance fields at runtime.

• Dart & Java:
  • Fix return statement with value/expression ;
• Java:
  • Better/shorter code for String concatenation.

• Dart & Java11:
  • Better definition of static methods.
  • Class object instance.

• ASTCodeBlock -> ASTBlock.
• ASTCodeRoot -> ASTRoot.
• ASTCodeClass -> ASTClass.

• Any part of an ASTNode can have an async resolution. This allows the mapping of external functions that returns a Future or other languages that accepts async at any point.

• Better Identification of number of parameters of mapped functions.

• Class/Root statements are executed once, and a context for each Class/Root is held during VM execution.

• Split apollovm_ast.dart into multiple ast/apollovm_ast_*.dart files.

• Fix else branch indentation.

• Java 11 is closer to Dart 2 than Java 8.

• Dart & Java11:
  • Support if, else if and else branches.

• Dart & Java8:
  • Support to expression comparison operators ==, !=, >, <, >=, <=.

• Dart:
  • Added support for string templates:
    • including variable access: $x.
    • including expressions: ${ x * 2 }.
    • Not implemented for multiline string yet.
• Java8:
  • Support for string concatenation.

• Java8:
  • Translate string templates to Java String concatenations.

• Dart:
  • Raw single line and raw multiline line strings.
  • Improved parser tests for literal String.

• ASTType.isInstance.
• Function call now checks type signature and type inheritance.

• Dart:
  • Single line and multiline line strings with escaped chars.
• Java8:
  • Single line strings with escaped chars.

• Dart:
  • Expression operations: +, -, *, /, ~/.
• Java8:
  • Expression operations: +, -, *, /.

• Now can call a class method or a function.

• Now supporting Java8 and Dart.

• Dart:
  • Basic class definition.
• Java8:
  • Basic class definition.