* 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
* Update grammar
* Implement selfIs in BObjectImp
* Add tests
* Update grammar
* Support obj.function as a MemberAccess [1/2]
- AST generation changes
* Support obj.function as a MemberAccess [2/2]
- add funcref index to eprog class table ctor entry
- allow check_mro on non-class inst (skip ctor calls)
* Move address of funcref into funcref table
* Add funcref.new()
- Add class index to funcref table entry
- Add MTH_NEW
* Fix formatting
* Address self-review comments
* Some more tests
* Address self-review comments
* Update grammar
* Remove ObjMember read_only, hidden
No need to special-handle MBR_FUNCTION
* Addres GitHub CI annotations
- '=': conversion from 'size_t' to 'unsigned int', possible loss of data
* 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
* fixed missing space when packing funcrefs
pack functioncall during group formatting without forcing a newline
* error if resulting format string is empty
* core changes
* do not start a newline when next part is a closing parenthesis during
groupformatting
* pkg loading is again quiet
* more formatting improvements:
replace inside of comments tabs with spaces if UseTabs is false
do not strip whitespaces at the beginning of linecomments
better handling of long lines eg string additions
"binpack":
if an array fits equally into up to 3 lines use this instead of having each element in a newline
struct/dicts get only packed if they fit into a single line, or half of the room for two lines
align comments in statements
* fixed linecomment forcing newline in simple splits
formatting of functionexpressions
```
@(blubb) {
blah;
};
```
* fixed windows lineendings
fixed extra newline before long comment in certain situations
added option FormatterFormatInsideComments to deactivate trimming and
replacing of tabs
* fixed typo..
ecompile cfg is now FormatterIndentLevel
* FormatterBracketAttachToType: array{} vs array {}
FormatterAllowSingleLines: allow single line case/functionrefs
* align case label expressions
comments at the end still make the expression packable
other bugs
* better detection of case labels, by buffering the text. fixed more
problems with comments while packing lines
* do not allow more then 3 lines to be packed to a single one
* fixed hopefully last bug with comments and packing
removed FormatterAllowSingleLines
added
FormatterAlignTrailingComments
FormatterAlignConsecutiveShortCaseStatements
FormatterAllowShortCaseLabelsOnASingleLine
FormatterAllowShortFuncRefsOnASingleLine
* better linesplits when prefferedBreak is used (functions with params)
* fixed unalign lines with comments in arrays
* simplified ecompile code, use callback for compilation during iteration
through the directories.
use for pkgs recursive_directory_iterator
* core-changes
* onlinedocs
* onlinedocs-typo
* corrected cfg
* do not touch comments at all when disabled
detect aligned */
* fixed group formatting in var statements in more complicated situations
* when packing finishes right before the last element check if this
element also fit into the last line
* remaining ); or similar parts dont start a new line during group
formatting
* fixed edge cases of preferredBreak tactic with paranthesis alignment
* changed defaults, updated docs
* Formatter: variable declaration list gets aligned with "var" breaked at
the comma.
if a linebreak happens while a paranthesis is open align next line with it
* added corechanges
* 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
* improved escript formatter when formatting if's/function parameters
logical operators get now a preferred break style same for commas in
function/program parameters. split based on this flag the line
* when logical "and/or" and commas from function parameters are in one
line only split based on logical ones
* core changes
* 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
* Squash only prettify changes from escript_formating_try
* support of "format-off" / "format-on" comments to mark areas without
formatting
* fix typo
* added FormatterIdentLevel, FormatterMergeEmptyLines cfg entry
better line splits for dicts/arrays
* added several spacing options. the current setting list is now:
//LineWidth
FormatterLineWidth 80
// keep original keyword spelling
FormatterKeepKeywords 0
// number of spaces for ident
FormatterIdentLevel 2
// multiple newlines get merged to a single
FormatterMergeEmptyLines 1
// space between emtpy parenthesis eg foo() vs foo( )
FormatterEmptyParenthesisSpacing 0
// space between emtpy brackets eg struct{} vs struct{ }
FormatterEmptyBracketSpacing 0
// space after/before parenthesis in conditionals
// eg if ( true ) vs if (true)
FormatterConditionalParenthesisSpacing 1
// space after/before parenthesis
// eg foo( true ) vs foo(true)
FormatterParenthesisSpacing 1
// space after/before brackets
// eg array{ true } vs array{true}
FormatterBracketSpacing 1
// add space after delimiter comma or semi in for loops
// eg {1, 2, 3} vs {1,2,3}
FormatterDelimiterSpacing 1
// add space around assignment
// eg a := 1; vs a:=1;
FormatterAssignmentSpacing 1
// add space around comparison
// eg a == 1 vs a==1
FormatterComparisonSpacing 1
// add space around operations
// eg a + 1 vs a+1
FormatterOperatorSpacing 1
// use \r\n as newline instead of \n
FormatterWindowsLineEndings 0
* added tab support
// use tabs instead of spaces
FormatterUseTabs 0
// tab width
FormatterTabWidth 4
* extended example ecompile.cfg with formatter settings
* cleanup
* program args comma is optional...
fixed line comments in group splitting
* since tokenids are now correct no more guessing for linecomments needed
* comments use as start tokenid the whitespace token if its on the same
line
* splitted processing from linebuilding
* renamed TokenPart to FmtToken better matches the purpose.
Comments get directly stored as FmtToken
started with a context enum
* better(?) formatting for groups
* fix eof rawlines
added check that all comments/rawlines got parsed
* const correctness
* datatype adapted to antlr
* fixed warnings
* added InsertNewlineAtEOF
* add newline at the end if the original file had one
dont strip comment whitespace if its somejind of "header block"
use the defined lineending for /* */ comments
* docs
* \r\n is default on windows \n otherwise
* fixed warning
---------
Co-authored-by: Kevin Eady <8634912+KevinEady@users.noreply.github.com>
