Fix use of a[LAST] as an lvalue (fixes #163)

Author: ghewgill

src/analyzer.cpp

@@ -1286,15 +1286,50 @@ const ast::Expression *Analyzer::analyze(const pt::SubscriptExpression *expr)
         }
         type = arraytype->elementtype;
         const ast::ReferenceExpression *ref = dynamic_cast<const ast::ReferenceExpression *>(base);
-        // This check for ArrayReferenceRangeExpression is a stupendous hack that
-        // allows expressions like a[LAST] (which is compiled as a[LAST TO LAST][0])
-        // to work. Without this, the subscript [0] on the range expression tries
-        // to generate the address of the base so it can apply an INDEXAR opcode.
-        // Since the range expression is really a function call, it has no address.
-        if (ref != nullptr && dynamic_cast<const ast::ArrayReferenceRangeExpression *>(ref) == nullptr) {
-            return new ast::ArrayReferenceIndexExpression(type, ref, index, false);
+        if (ref != nullptr) {
+            if (expr->from_last) {
+                return new ast::ArrayReferenceIndexExpression(
+                    type,
+                    ref,
+                    new ast::AdditionExpression(
+                        new ast::SubtractionExpression(
+                            new ast::FunctionCall(
+                                new ast::VariableExpression(
+                                    ref->type->methods.at("size")
+                                ),
+                                { ref }
+                            ),
+                            new ast::ConstantNumberExpression(number_from_sint32(1))
+                        ),
+                        index
+                    ),
+                    false
+                );
+            } else {
+                return new ast::ArrayReferenceIndexExpression(type, ref, index, false);
+            }
         } else {
-            return new ast::ArrayValueIndexExpression(type, base, index, false);
+            if (expr->from_last) {
+                return new ast::ArrayValueIndexExpression(
+                    type,
+                    base,
+                    new ast::AdditionExpression(
+                        new ast::SubtractionExpression(
+                            new ast::FunctionCall(
+                                new ast::VariableExpression(
+                                    base->type->methods.at("size")
+                                ),
+                                { base }
+                            ),
+                            new ast::ConstantNumberExpression(number_from_sint32(1))
+                        ),
+                        index
+                    ),
+                    false
+                );
+            } else {
+                return new ast::ArrayValueIndexExpression(type, base, index, false);
+            }
         }
     } else if (dicttype != nullptr) {
         if (not index->type->is_assignment_compatible(ast::TYPE_STRING)) {

src/parser.cpp

@@ -664,23 +664,15 @@ std::unique_ptr<Expression> Parser::parseAtom()
                                 last = parseExpression();
                             }
                             range.reset(new ArrayRange(tok_lbracket, std::move(index), first_from_end, std::move(last), last_from_end));
-                        } else {
-                            if (first_from_end) {
-                                range.reset(new ArrayRange(tok_lbracket, std::move(index), first_from_end, nullptr /*std::move(index)*/, first_from_end));
-                            }
                         }
                         if (tokens[i].type != COMMA && tokens[i].type != RBRACKET) {
                             error(2020, tokens[i], "']' expected");
                         }
                         ++i;
                         if (range != nullptr) {
                             expr.reset(new RangeSubscriptExpression(tok_lbracket, tokens[i].column, std::move(expr), std::move(range)));
-                            if (first_from_end && not has_range) {
-                                std::unique_ptr<Expression> index { new NumberLiteralExpression(Token(), number_from_uint32(0)) };
-                                expr.reset(new SubscriptExpression(tok_lbracket, tokens[i].column, std::move(expr), std::move(index)));
-                            }
                         } else {
-                            expr.reset(new SubscriptExpression(tok_lbracket, tokens[i].column, std::move(expr), std::move(index)));
+                            expr.reset(new SubscriptExpression(tok_lbracket, tokens[i].column, std::move(expr), std::move(index), first_from_end));
                         }
                     } while (tokens[i-1].type == COMMA);
                 } else if (tokens[i].type == LPAREN) {

src/pt.h

@@ -392,10 +392,11 @@ class ArrowExpression: public Expression {
 
 class SubscriptExpression: public Expression {
 public:
-    SubscriptExpression(const Token &token, size_t end_column, std::unique_ptr<Expression> &&base, std::unique_ptr<Expression> &&index): Expression(token, base->get_start_column(), end_column), base(std::move(base)), index(std::move(index)) {}
+    SubscriptExpression(const Token &token, size_t end_column, std::unique_ptr<Expression> &&base, std::unique_ptr<Expression> &&index, bool from_last): Expression(token, base->get_start_column(), end_column), base(std::move(base)), index(std::move(index)), from_last(from_last) {}
     virtual void accept(IParseTreeVisitor *visitor) const override { visitor->visit(this); }
     std::unique_ptr<Expression> base;
     std::unique_ptr<Expression> index;
+    bool from_last;
 };
 
 class InterpolatedStringExpression: public Expression {

t/array-slice.neon

@@ -65,3 +65,11 @@ dump(arr()[LAST-1 TO LAST])
 a[0 TO -1] := [9]
 dump(a)
 %= [9, 1, 5, 5, 5, 4]
+
+a[FIRST] := 0
+dump(a)
+%= [0, 1, 5, 5, 5, 4]
+
+a[LAST] := 0
+dump(a)
+%= [0, 1, 5, 5, 5, 0]