The SemanticAnalyzer was incorrectly reporting internal errors when a
class parent inherited from an unlinked class. The error will already
have been reported, when visiting the class parent.
* update grammar
* AST nodes and test
* Address self-review comments
- Replace `super` comment with something more explanatory
- Rename `make_user_function`
* add class analysis for uninit functions
* fix ast test after disallowing static uninit funcs
* use std::ranges::find_if
* add tests
* use SUPER constant; add test
* Remove unreachable code leftover from #809
Since #809, the super function is only generated for a class when
registering a parent class, and therefore it will always have a body. A
"No base class defines a constructor" will only occur if super was never
generated, and is handled in the "No function linked through
FunctionResolver" section of semantic analyzer.
* Address review comments
- use std::ranges::move instead of move iterators
- use std::is_same_v<> vs std::is_same<>::value
- use switch vs chained ternary conditionals
* update escript guide, create tests that are in escript guide
* add core-changes
* Error on uninit and defined constructor
* Move methods' FunctionLink construction to builder
This allows the error message for the uninit function to have a "See
Also" that point to the defined function.
* Move error checks for uninit and defined functions
These semantic checks should be in the ... SemanticAnalyzer.
* fix typo in core-changes
* move compiler-generated ctor registration to within class declaration registration; update test error messages
* add more ctor inheritance tests
* skip "Unknown identifier" error for calling undefined ctor
* add test for actual, previously crashing source
* add test for actual, previously crashing source
* move compiler-generator super registration to within class declaration registration
* add super local var test
* make register_available_generated_function private
* remove ClassDeclaration::has_super_ctor
This property was based on if FunctionResolver created the function, so
the logic can be moved to FunctionResolver.
* add core-changes
* use constant for "super" string
* fix enum classes entries without initializer
* docs
* update grammar to support scoped identifiers in case labels
* add support for enum class constants in case statements
* add ScopableName to ConstDeclaration; formatting fixes; tests
* update docs
* use c++20
* increased used clang version
* compiler report and logfacility use now compile time formatting, which
means that the formatstring gets checked at compile time. (which found 2 errors)
adapted a few places since report only accepts formatting arguments
adapted a few places with logging since char[] is compile time
formatting and string or chr* is runtime formatting
* use std::ranges instead of boost
* disabled pragma_assume vs specific macro (I guess noone cares)
* needed to fix ancient ms exception code
* modernized SpinLock
* removed unused code in ECompile
* replaced std::filesystem::path::u8string with string. It now returns an actual u8string type
* cleanup layers.h added the defines for other layers which where before
only defined in the pkt
* osmod::OpenConnection and HTTPRequest cleanup: early outs, dont check for pChild which is
only needed for startscript and placed suspend at the very last
position
* fix warning
* rebuild cache with new compiler version
* define c++ standard for external libs where possible
* added fixme
* compile time optimization:
int with doubles and strings
doubles with ints and strings
strings with ints and doubles
* bool with other types, more unary ops, float branch optimizer
* more tests
fixed bool to dbl compare
* output cleanup
more tests
* optimize string values in if statements, optimize ternary operator
* optimize elvis, addes missing files, code cleanup
* use array to keep unoptimized if branch in funcexpr tests
* missing include
* better readable testdata
* removed file
* optimize while and dowhile loops if predicate is a compile time known
value
* cleaner variant of loop optimization?
* added ConstantPredicateLoop Node used by the optimizer for constant loop
predicates
optimize repeat until loop
change tests to run the loops more then once to be sure they work
correctly
* test break/continue with label for constant-loop
* docs
* update grammar
* add ast nodes; ast building
* Rename to unpacking
* semantic analysis
* executor work part 1, unpacking indices
* renamings; implement index binding
* small cleanup
* use multi_index; more tests
* use multi_index only for rest, otherwise list
* initial formatting
* add missing token decoding
* address self-review comments
* formatting tweaks
* add test for var binding in classes
* add StringIterator
* fix spread tests
* add cfgfile iterator; add cfgelem opersubscript; tests
* add iterator for SQLResultSet and SQLRow; tests
* Copy value in take global/local
* Allow any iterable can index rest unpacking
Always use dictionary as rest object in index unpacking
* add docs, core-changes, doc tests
* formatting changes...
* address self-review comments
* update formatter, format all binding test srcs
* address review comments
- unset var scope
* add cfgfile/cfgelem docs
* reformat objref svg
* Make constructor_link nullable; WIP generated function builder changes
* saving work
* saving work, need to resolve double call
* hopefully finish up super inherited constructors
* Error if no base class has ctor
* Fix AddressSanitizer error...?
* Revert unnecessary edit
* Remove duplicate code
* Update pol-core/bscript/compiler/astbuilder/GeneratedFunctionBuilder.cpp
* Associate class descriptor with class instance
* Skeleton of BClassInstance, update tests
* Correctly handle methods on class instances
* Support calling members as methods
* Update super-multiple test
* Track called ctors; Introduce ins_check_mro
* Move class method funcref class to Executor
* Address GitHub CI annotations
- 'argument': conversion from 'size_t' to 'unsigned int'
* Update pol-core/bscript/bclassinstance.cpp
* Introduce BConstObject for class instances
* Fix unnecessary include in uotool
* Removed fixedalloc from BConstObject
* Additional test case
* Address Discord comments
- Reintroduce deleted copy assignment
* Fix super() calls with var args
* Small fixup
- Incorrect calling-scope in FunctionCall inside super() generated function
* Allow base classes that do not have constructors
* Fix defaults for super()
- Make SimpleValueCloner return an Expression
- Clone parameter's default value in GeneratedFunctionBuilder
* Grammar updates
- Make class parameters required
* Add ClassLink; wip with `super()` calls in ctors
* More AST nodes as ScopableNames
- (function call) Argument
- FunctionParameterDeclaration
* Add support for ambiguity handling
* Add few more tests
* Handle returns in constructors
- Semantic analysis to error on returning a value
- Introduce specific emitter method for returning from constructor
- Various tests
* Refactor super building to pre-semantic analysis
* Adding several tests, some are TODO
- found an issue with function resolver and funcrefs, fix later
* Address self-review comments
* Fix funcref global func references, tests
* Remove DefaultConstructorFunction
* Modify class parameters; update semantic analysis
- Use ClassDeclarationParameter for class decls vs Identifiers
- Update ScopableName to have equality for constructors and unscoped
function calls
- Update SemanticAnalyzer (self referencing base class, no ctor)
- Update, add tests
* Semantic updates; debug messaging updates
- Ensure base class is constructable
- Various fmt implementations for debugging
* Address self-review comments
* Add Report.debug
* Implement function call scoping
* Implement variable scoping
- Rename `Identifier::scope` to `calling_scope`, and concatenate the identifier scope into `name` if necessary.
- Track current scope in SemanticAnalyzer, similar to UserFunctionVisitor.
- Use current scope in SemanticAnalyzer when visiting identifiers.
* Update grammar for `::identifier` global scoping
* Introduce ScopableName for function resolution
* Address review comments
- Check for display_debugs missing
* Add ScopableName for identifier resolution
* Some cleanup
- Remove `Identifier::calling_scope`, as it is tracked in the semantic
analyzer
- Refactor `ScopeName::exists` to `global` for better clarification of
its use
- Removed `X::maybe_scoped_string/name`
* Address self-review comments
* Rename `Function::module_name` to `scope`
* Update grammar
* WIP with tracking classes
- Refactor AvailableUserFunction to AvailableParseTree
- Track ClassDeclarationContexts similarly to user functions
* Skeleton AST + tracking
* Finish up AST building
* Implement AST building
- TODO decide better name for UserFunctionBuilder/Visitor,
since it does both user functions and classes
* Update Prettifier
* Crude, first-round semantic analysis + codegen
- Currently, no real difference from regular functions
* Move class var statements to top level statements
* Add semantic analysis for base class existence
* Introduce ClassInstance AST node for generating `this` parameter
* Skeleton create class instance instruction
* Default ctor; 'this' byref; Error if multiple same baseclass
* Update grammar for scoped funcrefs and scoped identifiers
* Update prettifier, builders for scoped funcref, identifiers
* Fix CI issues
- Styling
- Shadowing
* Add grammar tests for scope; Remove scope from switch label
* Final draft todos
- Rename `VarStatement::class_name` to `scope`
- Comment why identifiers dont have scopes in enum declarations
- Remove code comment
* Update grammar
* Update parser and AST generator
* Update semantic analysis
* Executor implementation
- Move Executor stack modification logic to BFunctionRef
- Handle user function calls
- Handle expression function calls
* Tests
* Update existing listfile snapshots
- Adds variadic boolean to instruction stack
- Changes instruction counts and offsets
* Fix test issue
* Better implementation of calling user functions
* Add var-args-captures test
* Refactor continuation handling + handle variadic args
- Move stack modifications from make/withContinuation into the executor's handling of the continuation
- Only trim args in continuation call if function is not variadic
* Add var-args-continuation test (via array.filter)
* update escriptguide + formatting, docs
* Fix CI annotations
- '=': conversion from 'size_t' to 'unsigned int', possible loss of data
- declaration of 'continuation' hides previous local declaration
* initial poc of function expressions
- update grammar
- mock AST builder to return BBoolean(true) for a func expr
- update prettifier for skeleton implementation
* more skeleton work
create AST class FunctionExpression mimicking boolean value
* create ast UserFunction, add to workspace from functexpr
* can generate instructions
* reorg tests; add test for instructions
* can track FunctionDepth in Variable
* can get captures for funcexprs inside funcs.. tbd if this way of nesting works
* Implement create-functor instruction
- Move function depth from Variable to Variables
- Introduce stacking of `Variables` for function expresions via `FunctionVariableScope`
- Add `TOK_FUNCTOR` instruction for 'create-functor'
- Handle emitting a `FunctionExpression` AST node
- Update `emit.declare_variable` and `emit.access_variable` to account for function captures
- Remove `in_function` from instruction generator, as it is tracked via `UserFunction` stack
- Update tests
* Address Discord comments
- Swap pop param order
* Bubble up captured variables through nested functions
* Improve testing infrastructure; add some test cases
* Fix compilation error
* prepend captures to function parameters in funcref mth_call
* update tests
* move from function{} to @{}
* implementation fix
* some more tests
* update docs
* Some cleanup
* fix CI annotation warning
- 'argument': conversion from 'size_t' to 'VariableIndex', possible loss of data
* Address review comments
- Add `passert_always`
- Use better example in docs
* Some cleanup
- Remove unused functions
* initial support for function calls with expression callee
* Add support for identifier-named callees
* add compilation failure test; better code docs
* Add core-changes
* Address compiler warnings
- conversion from 'size_t' to 'unsigned int', possible loss of data
* Update grammar
* implementation
* tests
* update core-changes
* Address CI warnings
- declaration of 'method' hides previous local declaration
Renamed:
- GetMember to MemberAccess
- SetMember to MemberAssignment
- SetMemberByOperator to MemberAssignmentByOperator
- AssignVariableConsume to VariableAssignmentStatement
Warn on assignment statements like this, for which the OG compiler and the new compiler generate different code:
x := x := expr;
This fixes https://github.com/polserver/polserver/issues/311
The OG compiler doesn't optimize the leftmost assignment to an 'assign-variable-consume',
so a listfile for the above looks like this:
0: decl global #0
1: #
2: global #0
3: global #0
4: :=
5: "hi"
6: := #
7: progend
The new compiler optimizes like this:
0: decl global #0
1: #
2: global #0
3: "hi"
4: :=
5: global0 :=
6: progend
For reference, this is what a single assignment looks like:
0: declare global #0
1: # (consume)
2: "hi" (string) len=2 offset=0x1
3: global #0 :=
4: progend
* Fixed: if too many parameters were passed in a function call, an incorrect error message was displayed, and the compiler could even crash.
Also updated all of the error messages related to function call parameters to include the function name.
Adds:
- model/LocalVariableScopeInfo.h
Stores, for local variable blocks:
- the names of the local variables in the block
- the "base index" of those local variables within the current scope
The code generator uses these to clean up local variables as they go out of scope.
We also need this when writing debug information.
There is one part that differs from const declarations: 0-parameter function calls are allowed (by accident) as const values, but not for default parameter values.
Adds:
- ast/CaseDispatchDefaultSelector: AST node for a "default:" selector
- ast/CaseDispatchGroup: AST node for a collection of selectors and the code to execute
- ast/CaseDispatchGroups: AST node holding all groups in a case statement
- ast/CaseDispatchSelectors: AST node holding all selectors for one group
- ast/CaseStatement: AST node for a whole case statement
- codegen/CaseDispatchGroupVisitor: knows what to put in a case jump dispatch table
- codegen/CaseJumpDataBlock: knows how to build the entries in the data block
Also, detect multiple case selectors with the same value (or default). This is different from the OG compiler, which only detected duplicate `default:` selectors.
Adds:
- analyzer/FlowControlScope: Registers a break/continue scope
- analyzer/FlowControlScopes: Registry for break/continue scopes
- ast/LabelableStatement: Base class for AST nodes that can be labelled (loops and case)
- ast/LoopStatement: Base class for AST nodes for loops (have a break and continue label)
- ast/WhileLoop: AST node for a while loop
Adds:
- analyzer/Constants: holds constant name -> value for lookup
- ast/ConstDeclaration: AST node for a const declaration
- optimizer/ConstValidator: validates that an optimized expression is valid to use as a constant.
the Optimizer converts Identifiers that refer to a constant to the optimized constant value.
Process function call parameters to account for:
- default parameter values
- passing parameters by name
Also handle return within a function (I left this out of the previous PR)
Adds:
- astbuilder/SimpleValueCloner: clones values that are valid as constants and parameter default values.
Adds:
- ast/UserFunction AST node for user-defined functions.
- astbuilder/AvailableUserFunction: reference to a parse tree for a user function.
- The AST builder only generates ASTs for user functions that are actually referenced.
- astbuilder/UserFunctionVisitor: visits (builds an AST for) a parse tree for a user function.
- This happens after the .src or .inc file has been otherwise processed, so this class serves to hook up the correct SourceFileIdentifier to the AST.
Adds:
- ast/Block: a block scope that allows declaring local variables
- ast/IfThenElseStatement: AST node for if..elseif..else..endif statements
- model/FlowControlLabel: provides an anchor for jumps or calls.
- Function calls, break statements, continue statements, and loops will all use these.
Adds:
- analyzer/LocalVariableScope: tracks local variables created within a given scope.
- Instantiated on the stack during semantic analysis, this registers itself with LocalVariableScopes during construction and deregisters itself during destruction.
- Detects unused variables during deregistration
- analyzer/LocalVariableScopes: this is what LocalVariableScope registers with.
- keeps track of the stack of local scopes.
- can provide the current local scope, for var statements.
Other notes:
"Shadowed" variables: this is when a variable in one scope hides a variable in another, like so:
var a := 2;
if (a)
var a := 3;
a := 4;
endif
print(a); // still 2
"debug_variables": We'll use these later when writing debug files.
