nullableObject? no longer returns null. Instead, it breakelses null.

Generally, null is treated equivalently to :else in breakelse features.
This allows nullableObject?.else(...) and generally nullableObject? in if expressions.
Also, .else now creates a breakelse targetable scope on its left.

build.sh

@@ -34,7 +34,7 @@ fi
 
 FLAGS="$JFLAG -I$($LLVM_CONFIG --includedir) -L-L$($LLVM_CONFIG --libdir)"
 
-TAG=v0.3.1
+TAG=v0.4.0
 NEAT=.cache/bootstrap/"$TAG"/neat-"$TAG"-gcc/neat
 
 if [ ! -f "$NEAT" ]

src/neat/base.nt

@@ -1815,5 +1815,7 @@ void printAtErrorLoc(LocRange locRange, nullable FileIdTable fileIdTable, string
 }
 
 string getLine(string text, int line) {
-    return text.split("\n")[line];
+    auto lines = text.split("\n");
+    if (line >= lines.length) return "???????????????";
+    return lines[line];
 }

src/neat/class_.nt

@@ -1229,7 +1229,7 @@ bool isStrictSubtypeOf(Type first, Type second)
     // FIXME __init()
     auto astExpr = context.compiler.$expr ({
         auto base = $astBase;
-        mut uninitialized ($astNnType | fail nullptr_t) result;
+        mut uninitialized ($astNnType | nullptr_t) result;
         if (auto base = base) result = base;
         else result = null;
         result;

src/neat/elseexpr.nt

@@ -0,0 +1,127 @@
+module neat.elseexpr;
+
+macro import std.macro.listcomprehension;
+macro import std.macro.quasiquoting;
+
+import neat.base;
+import neat.bottom;
+import neat.either;
+import neat.expr;
+import neat.statements;
+import neat.util;
+
+/**
+ * Is this type a type that should trigger a breakelse?
+ * - :else
+ * - nullptr_t
+ */
+bool isElseTriggerType(Type type) {
+    if (type.instanceOf(SymbolIdentifierType).case(null: breakelse).name == "else") {
+        return true;
+    }
+    if (type.instanceOf(NullPointer)) return true;
+    return false;
+}
+
+class ASTElseExpr : ASTSymbol
+{
+    ASTSymbol base;
+
+    ASTSymbol else_;
+
+    this(this.base, this.else_, super) { }
+
+    override (Symbol | fail Error) compile(Context context) {
+        /**
+         * - make label
+         * - LabelIfScope
+         * - preallocate var
+         * if (true) {
+         *   var = base.case(:else: breakelse)
+         * } else {
+         *   var = else_
+         * }
+         * - var
+         */
+        auto ifLabel = context.getLabel;
+        auto context = context.withNamespace(new LabelIfScope(ifLabel, hasElse=true, context.namespace));
+        auto base = this.base.compile(context)?.beExpressionImplCall(context, base.locRange)?;
+        auto else_ = this.else_.compile(context)?.beExpressionImplCall(context, else_.locRange)?;
+        // won't be visible post-merge
+        bool elseIsBottom = !!else_.type.instanceOf(Bottom);
+        (Expression | fail Error) baseEither() {
+            if (auto either = base.type.instanceOf(Either)) {
+                return base;
+            }
+            if (auto canTreatAsEither = base.type.instanceOf(CanTreatAsEither)) {
+                return canTreatAsEither.toEitherType(context, base)?.case(null: breakelse);
+            }
+            return this.locRange.fail(
+                "'else' operator cannot be applied to non-sumtype $(base.type.repr)");
+        }
+        auto baseEither = baseEither?;
+        auto baseEitherType = baseEither.type.instanceOf(Either).notNull;
+        if (![any a.type.isElseTriggerType for a in baseEitherType.types]) {
+            return this.locRange.fail(
+                "'else' operator cannot be applied to sumtype without :else member");
+        }
+        auto merger = new TypeMerger;
+        mut nullable Type triggerType;
+        for (auto entry in baseEitherType.types) {
+            if (entry.type.isElseTriggerType) {
+                this.locRange.assert(!triggerType, "internal error: double trigger type")?;
+                triggerType = entry.type;
+            } else {
+                merger.add(new NullExpr(entry.type), __RANGE__, context)?;
+            }
+        }
+        merger.add(else_, __RANGE__, context)?;
+        auto mergedType = merger.type(context).notNull;
+        print("merged to $(mergedType) from $(baseEitherType.types) and $(else_.type)");
+        /**
+         * uninitialized mergedType result;
+         * if (true) { result = baseEither.case(:else: breakelse); }
+         * else { result = else_; }
+         */
+        auto astBaseEither = new ASTSymbolHelper(baseEither);
+        auto astTriggerType = new ASTSymbolHelper(triggerType);
+        auto astBaseBreakElse = context.compiler.$expr $astBaseEither.case($astTriggerType: breakelse);
+        auto baseBreakElse = astBaseBreakElse.compile(context)?.beExpression(__RANGE__)?;
+        auto lifetimeBaseBreakElse = baseBreakElse if elseIsBottom else baseBreakElse.take(context, __RANGE__)?;
+        auto baseBreakElseConvert = expectImplicitConvertTo(
+            context, lifetimeBaseBreakElse, mergedType, this.locRange)?;
+        auto elseConvert = expectImplicitConvertTo(context, else_, mergedType, this.locRange)?;
+        // If else is bottom, we can just use the lifetime of base directly.
+        auto lifetime = baseEither.info.lifetime if elseIsBottom else Lifetime.gifted;
+        auto result = new PairedTemporary(mergedType, lifetime, context.getUniqueId);
+        auto init = new UninitializeTemporaryStatement(result);
+        auto ifTrue = new AssignStatement(result, baseBreakElseConvert, __RANGE__);
+        auto ifFalse = new AssignStatement(result, elseConvert, __RANGE__);
+        auto trueTest = new BoolLiteral(true);
+        auto ifStmt = new IfStatement(ifLabel, trueTest, then=ifTrue, else_=ifFalse, __RANGE__);
+        return context.compiler.(wrap(sequence(init, ifStmt), result, null));
+    }
+
+    override string repr() => "($(base)).else($else_)";
+}
+
+// expr.else(expr)
+(nullable ASTSymbol | fail Error) parseElseExpr(Parser parser, LexicalContext lexicalContext, ASTSymbol current) {
+    parser.begin;
+    auto from = parser.from;
+    if (!(parser.acceptToken(TokenType.dot)
+        && parser.acceptIdentifier("else")
+        && parser.acceptToken(TokenType.lparen)))
+    {
+        parser.revert;
+        return null;
+    }
+    parser.commit;
+
+    auto elseExpr = lexicalContext.compiler.parseExpression(parser, lexicalContext)?;
+    auto range = parser.to(from);
+    range.assert(!!elseExpr, () => "expression expected")?;
+    auto elseExpr = elseExpr.notNull;
+    parser.expectToken(TokenType.rparen)?;
+    return new ASTElseExpr(base=current, else_=elseExpr, range);
+}

src/neat/stuff.nt

@@ -16,6 +16,7 @@ import neat.bottom;
 import neat.class_;
 import neat.decl;
 import neat.delegate_;
+import neat.elseexpr;
 import neat.either;
 import neat.enums;
 import neat.expr;
@@ -135,8 +136,6 @@ class DefineClassIntf : FinishedSymbol
              * mut T mut[] foo;
              * foo ~= T(); // mut T[] - the array value is mutable
              * foo[0] = T(); // T mut[] - the array elements are mutable
-             *
-             * TODO: actually implement this
              */
             bool arrayIsMutable = parser.acceptIdentifier("mut");
             if (parser.acceptToken(TokenType.lsquarebracket)) {
@@ -732,9 +731,8 @@ class WrapReference : Reference
     if (autoCall) return (:mismatch, locRange.fail("cannot call"));
     nullable Expression expr = target.instanceOf(Expression);
     // TODO
-    // auto funcptr = expr?.type.instanceOf(FunctionPointer);
-    mut nullable FunctionPointer funcptr;
-    if (expr) funcptr = expr.type.instanceOf(FunctionPointer);
+    // auto funcptr = expr?.type.instanceOf(FunctionPointer).else(null);
+    auto funcptr = expr.case(Expression e: e.type.instanceOf(FunctionPointer));
     if (expr && funcptr) {
         auto result = validateCall(context, funcptr.params, astArgs, "", variadic=false, locRange)?.case(
             (:argCastError, Error err): return (:argCastError, err),
@@ -1247,18 +1245,14 @@ class ASTPropagateFailureExpr : ASTSymbol
         for (k, v in either.types) {
             ASTSymbol expr() {
                 auto a = new ASTIdentifier("a", false, __RANGE__);
-                // Aaaaaaaugh!
-                // if (v.type.instanceOf(SymbolIdentifierType).case(null: breakelse).name == "else") {
-                if (auto asIdentifierType = v.type.instanceOf(SymbolIdentifierType)) {
-                    if (asIdentifierType.name == "else") {
-                        return new ASTBreakElse(__RANGE__);
-                    }
+                if (v.type.isElseTriggerType) {
+                    return new ASTBreakElse(this.locRange);
                 }
-                if (v.fail) return new ASTReturn(a, __RANGE__);
+                if (v.fail) return new ASTReturn(a, this.locRange);
                 return a;
             }
             cases ~= ASTEitherCaseExprCase(
-                __RANGE__,
+                this.locRange,
                 new ASTSymbolHelper(v.type),
                 "a",
                 fail=v.fail,
@@ -1285,26 +1279,6 @@ class ASTPropagateFailureExpr : ASTSymbol
     return new ASTPropagateFailureExpr(left, parser.to(from));
 }
 
-// expr.else(expr)
-(nullable ASTSymbol | fail Error) parseElseExpr(Parser parser, LexicalContext lexicalContext, ASTSymbol current) {
-    parser.begin;
-    if (!(parser.acceptToken(TokenType.dot)
-        && parser.acceptIdentifier("else")
-        && parser.acceptToken(TokenType.lparen)))
-    {
-        parser.revert;
-        return null;
-    }
-    auto from = parser.from;
-    parser.commit;
-
-    auto elseExpr = lexicalContext.compiler.parseExpression(parser, lexicalContext)?;
-    parser.to(from).assert(!!elseExpr, () => "expression expected")?;
-    auto elseExpr = elseExpr.notNull;
-    parser.expectToken(TokenType.rparen)?;
-    return lexicalContext.compiler.$expr $current.case(:else: $elseExpr);
-}
-
 (nullable ASTSymbol | fail Error) parseProperties(ParserImpl parser, LexicalContext lexicalContext)
 {
     mut (:inc | :dec | :none) preincdec = :none, postincdec = :none;
@@ -1313,14 +1287,9 @@ class ASTPropagateFailureExpr : ASTSymbol
     else if (parser.acceptToken2(TokenType.plus, TokenType.plus)) preincdec = :inc;
     auto toPre = parser.to(fromPre);
 
-    /**
-     * TODO
-     * mut ASTSymbol current = parseExpressionBase(parser, lexicalContext)?.case(null: return null);
-     */
-    mut uninitialized ASTSymbol current;
-    if (auto base = parseExpressionBase(parser, lexicalContext)?)
-        current = base;
-    else return null;
+    // TODO
+    // mut ASTSymbol current = parseExpressionBase(parser, lexicalContext)??.else(return null);
+    mut ASTSymbol current = parseExpressionBase(parser, lexicalContext)?.case(null: return null);
 
     while (true) {
         if (ASTSymbol instanceOf = parser.parseInstanceOf(lexicalContext, current)?) {
@@ -2369,7 +2338,7 @@ class ASTIfStatement : ASTStatement
             ASTVarDeclStatement vardecl: {
                 auto initial = vardecl.initial.compile(context)?.beExpressionImplCall(context, vardecl.locRange)?;
                 // TODO
-                // auto declType = vardecl.type.compile(context)?.beType(vardecl.type.locRange)? if vardecl.type else null;
+                // auto declType = vardecl.type?.compile(context)?.beType(vardecl.type.locRange).else(null);
                 mut nullable Type declType;
                 if (vardecl.type)
                     declType = vardecl.type.compile(context)?.beType(vardecl.type.locRange)?;

src/std/macro/listcomprehension.nt

@@ -62,6 +62,8 @@ class ASTListComprehension : ASTSymbol
         mut auto type = astType.compile(context)?;
 
         bool defaultIsNullExpr() {
+            // TODO
+            // return default_?.else(return false)
             return default_.case(null: return false)
                 .(compiler.destructAstIdentifier(that))
                 .case(string name: name == "null", :none: false);

test/runnable/eithertest.nt

@@ -92,6 +92,11 @@ class Bar {
     this(this.foo) {}
 }
 
+class Baz {
+    nullable Foo foo;
+    this(this.foo) {}
+}
+
 void testObjHack() {
     bool test(nullable Foo nullableFoo) {
         Foo foo = nullableFoo.case(null: return false);
@@ -101,7 +106,7 @@ void testObjHack() {
     assert(test(new Foo));
 
     nullable Foo test2(nullable Bar bar) {
-        Foo foo = bar?.foo;
+        Foo foo = bar.case(null: return null).foo;
         return foo;
     }
     assert(!test2(null));
@@ -114,4 +119,12 @@ void testObjHack() {
     }
     assert(!test3(null));
     assert(test3(new Foo));
+
+    void test4(nullable Baz nullableBaz, (Foo | bool) outcome) {
+        assert(nullableBaz?.foo.else(false) == outcome);
+    }
+    auto foo = new Foo;
+    test4(null, false);
+    test4(new Baz(null), false);
+    test4(new Baz(foo), foo);
 }

test/runnable/lifetime.nt

@@ -601,6 +601,33 @@ void test_either_replace()
     assert(trace == "-S0 -T0 -U0");
 }
 
+void test_else_prop()
+{
+    dbg("- else property");
+    {
+        string trace;
+        {
+            nullable C c = new C(S("S", &trace, 0));
+            auto value = c.else(false);
+            assert(trace == "+S1 -S0");
+        }
+        assert(trace == "+S1 -S0 -S1");
+    }
+    {
+        string trace;
+        (int | :else) test = :else;
+        test.else(new C(S("S", &trace, 0)));
+        assert(trace == "+S1 -S0 -S1");
+    }
+    {
+        string trace;
+        (int | :else) test = 0;
+        test.else(new C(S("S", &trace, 0)));
+        // else block is never evaluated
+        assert(trace == "");
+    }
+}
+
 class ErrorPropTest {
     (void | fail S) field;
     this() { }
@@ -1162,6 +1189,7 @@ void main()
     test_class_member_ref;
     test_either_member;
     test_either_replace;
+    test_else_prop;
     test_error_prop;
     test_array_cat;
     test_statement_expr;