Merge remote-tracking branch 'upstream/main' into feature-add-cwd-option

Author: helmesjo

.github/workflows/build-cppfront.yaml

@@ -22,7 +22,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        runs-on: [ubuntu-latest]
+        runs-on: [ubuntu-22.04]
         compiler: [g++-10, g++-11, g++-12, clang++-12, clang++-14]
         cxx-std: ['c++20', 'c++2b']
         exclude:
@@ -35,12 +35,21 @@ jobs:
           - compiler: clang++-14
             cxx-std: 'c++2b'
         include:
-          - runs-on: macos-11
-            compiler: clang++
-            cxx-std: 'c++20'
           - runs-on: macos-latest
             compiler: clang++
             cxx-std: 'c++20'
+          - runs-on: ubuntu-24.04
+            compiler: clang++-16
+            cxx-std: 'c++20'
+          - runs-on: ubuntu-24.04
+            compiler: clang++-17
+            cxx-std: 'c++20'
+          - runs-on: ubuntu-24.04
+            compiler: clang++-18
+            cxx-std: 'c++20'
+          - runs-on: ubuntu-24.04
+            compiler: g++-14
+            cxx-std: 'c++2b'
     runs-on: ${{ matrix.runs-on }}
     env:
       CXX: ${{ matrix.compiler }}

.github/workflows/regression-tests.yml

@@ -11,27 +11,70 @@ on:
 
 jobs:
   regression-tests:
-    name: Run on ${{ matrix.os }} using ${{ matrix.compiler }}
+    name: ${{ matrix.shortosname }} | ${{ matrix.compiler }} | ${{ matrix.cxx_std }} | ${{ matrix.stdlib }} | ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     env:
       CXX: ${{ matrix.compiler }}
 
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest]
-        compiler: [g++-10, g++-13, clang++-15]
+        os: [ubuntu-24.04]
+        shortosname: [ubu-24]
+        compiler: [g++-14, g++-13]
+        cxx_std: [c++2b]
+        stdlib: [libstdc++]
         include:
           - os: ubuntu-20.04
+            shortosname: ubu-20
+            compiler: g++-10
+            cxx_std: c++20
+            stdlib: libstdc++
+          - os: ubuntu-24.04
+            shortosname: ubu-24
+            compiler: clang++-18
+            cxx_std: c++20
+            stdlib: libstdc++
+          - os: ubuntu-22.04
+            shortosname: ubu-22
+            compiler: clang++-15
+            cxx_std: c++20
+            stdlib: libstdc++
+          - os: ubuntu-22.04
+            shortosname: ubu-22
+            compiler: clang++-15
+            cxx_std: c++20
+            stdlib: libc++-15-dev
+          - os: ubuntu-20.04
+            shortosname: ubu-20
             compiler: clang++-12
+            cxx_std: c++20
+            stdlib: libstdc++
           - os: macos-14
+            shortosname: mac-14
             compiler: clang++
+            cxx_std: c++2b
+            stdlib: default
           - os: macos-13
+            shortosname: mac-13
             compiler: clang++
+            cxx_std: c++2b
+            stdlib: default
           - os: macos-13
+            shortosname: mac-13
             compiler: clang++-15
-          - os: windows-latest
+            cxx_std: c++2b
+            stdlib: default
+          - os: windows-2022
+            shortosname: win-22
+            compiler: cl.exe
+            cxx_std: c++latest
+            stdlib: default
+          - os: windows-2022
+            shortosname: win-22
             compiler: cl.exe
+            cxx_std: c++20
+            stdlib: default
     steps:
     - name: Checkout repo
       uses: actions/checkout@v4
@@ -46,21 +89,21 @@ jobs:
       if: startsWith(matrix.os, 'ubuntu') || startsWith(matrix.os, 'macos')
       run: |
         cd regression-tests
-        bash run-tests.sh -c ${{ matrix.compiler }} -l ${{ matrix.os }}
+        bash run-tests.sh -c ${{ matrix.compiler }} -s ${{ matrix.cxx_std }} -d ${{ matrix.stdlib }} -l ${{ matrix.os }}
 
     - name: Run regression tests - Windows version
       if: matrix.os == 'windows-latest'
       run: |
         "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && ^
         git config --local core.autocrlf false && ^
         cd regression-tests && ^
-        bash run-tests.sh -c ${{ matrix.compiler }} -l ${{ matrix.os }}
+        bash run-tests.sh -c ${{ matrix.compiler }} -s ${{ matrix.cxx_std }} -d ${{ matrix.stdlib }} -l ${{ matrix.os }}
       shell: cmd
 
     - name: Upload patch
       if: ${{ !cancelled() }}
       uses: actions/upload-artifact@v4
       with:
-        name: ${{ matrix.os }}-${{ matrix.compiler }}.patch
-        path: regression-tests/${{ matrix.os }}-${{ matrix.compiler }}.patch
+        name: ${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.cxx_std }}-${{ matrix.stdlib }}.patch
+        path: regression-tests/${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.cxx_std }}-${{ matrix.stdlib }}.patch
         if-no-files-found: ignore

CITATION.cff

@@ -0,0 +1,12 @@
+cff-version: 1.2.0
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+title: cppfront
+authors:
+  - given-names: Herb
+    family-names: Sutter
+repository-code: 'https://github.com/hsutter/cppfront'
+abstract: A personal experimental C++ Syntax 2 -> Syntax 1 compiler
+license: CC-BY-NC-ND-4.0

docs/cpp2/common.md

@@ -67,7 +67,7 @@ All lists use `,` commas between list items, and may be enclosed by
 
 For example:
 
-``` cpp title="Lists, using optional trailing commas just because we can" hl_lines="1 4 6 7"
+``` cpp title="Lists" hl_lines="1 4 6 7"
 print: <T,U> (t: T, u: U) = std::cout << t << u << "\n";
 
 main: () = {
@@ -223,7 +223,6 @@ Unary suffix operators must not be preceded by whitespace. When `*`, `&`, and `~
 |---|---|---|
 | `#!cpp *` | `#!cpp pobj* * 42` | `#!cpp (*pobj)*42` |
 | `#!cpp &` | `#!cpp obj& & mask` <p> (note: allowed in unsafe code only) | `#!cpp &obj & mask` |
-| `#!cpp ~` | `#!cpp ~val ~ bitcomplement` | `#!cpp val~ ~ bitcomplement` |
 
 For more details, see [Design note: Postfix unary operators vs binary operators](https://github.com/hsutter/cppfront/wiki/Design-note%3A-Postfix-unary-operators-vs-binary-operators).
 

docs/cpp2/contracts.md

@@ -32,7 +32,7 @@ For example:
 ``` cpp title="Precondition and postcondition examples" hl_lines="2 3"
 insert_at: (container, where: int, val: int)
     pre<bounds_safety>( 0 <= where <= container.ssize(), "position (where)$ is outside 'container'" )
-    post       ( container.ssize() == container.ssize()$ + 1 )
+    post              ( container.ssize() == container.ssize()$ + 1 )
 = {
     _ = container.insert( container.begin()+where, val );
 }

docs/cpp2/declarations.md

@@ -254,7 +254,7 @@ main: () = {
     //  Assertion that the size is the square of 4
     static_assert( ints.size() == 16 );
 
-    //  And if can be used at run time, with run time values
+    //  And it can be used at run time, with run time values
     std::cout << "the square of 4 is (square(4))$\n";
 }
 //  Prints:

docs/cpp2/expressions.md

@@ -49,7 +49,7 @@ For example:
 
 
 
-## <a id="wildcard"></a> `_` — the "don't care" wildcard, including explicit discard
+## <a id="wildcard"></a> <a id="discard"></a> `_` — the "don't care" wildcard, including explicit discard
 
 `_` is pronounced **"don't care"** and allowed as a wildcard in most contexts. For example:
 
@@ -173,13 +173,11 @@ Here are some `as` casts with their Cpp1 equivalents. In this table, uppercase n
 
 ## <a id="inspect"></a> `inspect` — pattern matching
 
-An `inspect expr -> Type` expression allows pattern matching using `is`.
+An `inspect expr -> Type = { /* alternatives */ }` expression allows pattern matching using `is`.
 
 - `expr` is evaluated once.
 
-- Each alternative spelled `is C` is evaluated in order as if called with `expr is C`.
-
-- If an alternative evaluates to `#!cpp true`, then its `#!cpp = alternative;` body is used as the value of the entire `inspect` expression, and the meaning is the same as if the entire `inspect` expression had been written as just `#!cpp :Type = alternative;` — i.e., an unnamed object expression (aka 'temporary object') of type `Type` initialized with `alternative`.
+- Each alternative is spelled `is C = statement;` and are evaluated in order. Each `is C` is evaluated as if called with `expr is C`, and if it evaluates to `#!cpp true`, then its `#!cpp = alternative;` body is used as the value of the entire `inspect` expression, and the meaning is the same as if the entire `inspect` expression had been written as just `#!cpp :Type = alternative;` — i.e., an unnamed object expression (aka 'temporary object') of type `Type` initialized with `alternative`.
 
 - A catchall `is _` is required.
 
@@ -277,7 +275,7 @@ For example:
 
 ``` cpp title="Capture in contract postconditions" hl_lines="2"
 push_back: (coll, value)
-    [[post: coll.ssize() == coll.ssize()$ + 1]]
+    post(coll.ssize() == coll.ssize()$ + 1)
     //  Paste the value of `coll.ssize()`
 = {
     // ...

docs/cpp2/functions.md

@@ -27,20 +27,39 @@ func: (
 }
 ```
 
-There are six ways to pass parameters that cover all use cases:
+There are six ways to pass parameters that cover all use cases, that can be written before the parameter name:
 
 | Parameter ***kind*** | "Pass me an `x` I can ______" | Accepts arguments that are | Special semantics | ***kind*** `x: X` Compiles to Cpp1 as |
 |---|---|---|---|---|
 | `in` (default) | read from | anything | always `#!cpp const`<p>automatically passes by value if cheaply copyable | `X const x` or `X const& x` |
 | `copy` | take a copy of | anything | acts like a normal local variable initialized with the argument | `X x` |
 | `inout` | read from and write to | lvalues | | `X& x` |
-| `out` | write to (including construct) | lvalues, including uninitialized lvalues | must `=` assign/construct before other uses | `cpp2::out<X>` |
-| `move` | move from | rvalues | automatically moves from every definite last use | `X&&` |
+| `out` | write to (including construct) | lvalues (including uninitialized) | must `=` assign/construct before other uses | `cpp2::impl::out<X>` |
+| `move` | move from (consume the value of) | rvalues | automatically moves from every definite last use | `X&&` |
 | `forward` | forward | anything | automatically forwards from every definite last use | `T&&` constrained to type `X` |
 
-
 > Note: All parameters and other objects in Cpp2 are `#!cpp const` by default, except for local variables. For details, see [Design note: `#!cpp const` objects by default](https://github.com/hsutter/cppfront/wiki/Design-note%3A-const-objects-by-default).
 
+For example:
+
+``` cpp title="Declaring parameter kinds" hl_lines="2 3 10"
+append_x_to_y: (
+    x       : i32,          // an i32 I can read from (i.e., const)
+    inout y : std::string   // a string I can read from and write to
+    )
+= {
+    y = y + to_string(x);   // read x, read and write y
+}
+
+wrap_f: (
+    forward x               // a generic value of deduced type I can forward
+)                           //  (omitting x's  type means the same as ': _')
+= {
+    global_counter += x;    // ok to read x
+    f(x);                   // last use: automatically does 'std::forward<T>(x)'
+}
+```
+
 
 ## <a id="return-values"></a> Return values
 
@@ -188,7 +207,7 @@ else {
 
 **`#!cpp do`** and **`#!cpp while`** are like always in C++, except that `(` `)` parentheses around the condition are not required. Instead, `{` `}` braces around the loop body *are* required.
 
-**`#!cpp for range do (e)`** ***statement*** says "for each element in `range`, call it `e` and perform the statement." The loop parameter `(e)` is an ordinary parameter that can be passed isoing any [parameter passing style](#parameters); as always, the default is `in`, which is read-only and expresses a read-only loop. The statement is not required to be enclosed in braces.
+**`#!cpp for range do (e)`** ***statement*** says "for each element in `range`, call it `e` and perform the statement." The loop parameter `(e)` is an ordinary parameter that can be passed using any [parameter passing style](#parameters); as always, the default is `in`, which is read-only and expresses a read-only loop. The statement is not required to be enclosed in braces.
 
 Every loop can have a `next` clause, that is performed at the end of each loop body execution. This makes it easy to have a counter for any loop, including a range `#!cpp for` loop.
 
@@ -247,6 +266,22 @@ if   i % 2 == 1         // if i is odd
 //      counter: 1, word: [Betty]
 ```
 
+Here is the equivalent of the Cpp1 code `for ( int i = 0; i < 10; ++i ){ std::cout << i; }`:
+
+``` cpp title="Equivalent of Cpp1 'for ( int i = 0; i < 10; ++i ){ std::cout << i; }'"
+(copy i := 0)
+while i < 10
+next  i++ {
+    std::cout << i;
+}
+```
+
+Line by line:
+
+- `(copy i := 0)`: Any statement can have [statement-local parameters](declarations.md#from-functions-to-local-scopes-and-back-again), and this is declaring `i` as an `int` that's local to the loop. Parameters by default are `const`, and for not-cheap-to-copy types they bind to the original value; so because we want to modify `i` we say `copy` to explicitly declare this is the loop's own mutable scratch variable.
+- `while i < 10`: The termination condition.
+- `next i++`: The end-of-loop-iteration statement. Note `++` is always postfix in Cpp2.
+
 
 ### Loop names, `#!cpp break`, and `#!cpp continue`
 

docs/cpp2/types.md

@@ -81,7 +81,7 @@ For example:
 abstract_base: type
 = {
     //  A pure virtual function: virtual + no body
-    print: (virtual this, msg: std::string);
+    print: (virtual this, msg: std::string) = { /*...*/ }
 
     // ...
 }
@@ -92,7 +92,7 @@ derived: type
     this: abstract_base;
 
     //  Explicit override
-    print: (override this, msg: std::string);
+    print: (override this, msg: std::string) = { /*...*/ }
 
     // ...
 }
@@ -199,7 +199,7 @@ mytype: type
     name:          std::string;
     social_handle: std::string = "(unknown)";
 
-    //  conversion from string
+    //  conversion from string (construction + assignment)
     operator=: (out this, who: std::string) = {
         name = who;
         //  if social_handle is not mentioned, defaults to: