scope test_leftArrowScript_objectScope

set flag OurSyncCollections.

!include once #1034831 // Gazelle 22 Function Include for Testing

sclass #Class1 {

  S hello(S x) { ret "hello " + x; }

}

svoid test_leftArrowScript_objectScope(LASMultiClassLoader cl default new LASMultiClassLoader(mc())) {

  // Accessing an instance field

  S classPrefix = "scriptClasses.";

  embedded O runScript(S code) {  

    var parser = enableScaffolding(new GazelleV_LeftArrowScriptParser()

      .classDefPrefix(classPrefix)

      .lasClassLoader(cl));

    ret leftArrowVerbose(parser, code);

  }

  // Access instance field without "this"

  assertEqualsVerbose(10, runScript([[

    class X {

      i: int <- 5

      def j { i plus i }

    }

    new X, j

  ]]));

  // Access superclass field without "this"

  assertEqualsVerbose(10, runScript([[

    class X {

      i: int <- 5

    }

    class Y extends X {

      def j { i plus i }

    }

    new Y, j

  ]]));

  // Make sure locally declared variables shadow fields

  assertEqualsVerbose(14, runScript([[

    class X {

      i: int <- 5

      def j { i: int <- 7; i plus i }

    }

    new X, j

  ]]));

  // Assign instance field without "this"

  assertEqualsVerbose(10, runScript([[

    class X {

      i: int

      def j { i <- 10; this }

    }

    new X, j, i

  ]]));

  // Assign instance field in superclass without "this"

  assertEqualsVerbose(10, runScript([[

    class X { i: int }

    class Y extends X {

      def j { i <- 10; this }

    }

    new Y, j, i

  ]]));

  // Call instance method without "this"

  assertEqualsVerbose(2, runScript([[

    class X {

      i: int <- 1

      def yo { i <- i plus 1 }

      def j { yo; i }

    }

    new X, j

  ]]));

  // Call instance method without "this" followed by "<"

  assertEqualsVerbose(6, runScript([[

    class X {

      def yo n  { 1 plus n }

      def j { yo < 5 }

    }

    new X, j

  ]]));

  // Special case: field & method with same name

  //   (refers to the field because it's inside an expression)

  assertEqualsVerbose(ll("o", "o"), runScript([[  

    class X {

      bla: S <- "o"

      def bla { "x" }

      def y { ll bla bla }

    }

    new X, y

  ]]));

  // Call superclass method without "this"

  assertEqualsVerbose(2, runScript([[

    class X {

      i: int <- 1

      def yo { i <- i plus 1 }

    }

    class Y extends X {

      def j { yo; i }

    }

    new Y, j

  ]]));

  // Same with arguments and return value

  assertEqualsVerbose(6, runScript([[

    class X {

      i: int <- 1

      def yo x { i <- i plus x; this }

      def j { yo 5, i }

    }

    new X, j

  ]]));

  // Same with "<"

  assertEqualsVerbose(6, runScript([[

    class X {

      i: int <- 1

      def yo x { i <- i plus x; this }

      def j { (yo < 5) i }

    }

    new X, j

  ]]));

  // Java superclass method with "<"

  assertEqualsVerbose("hello world", runScript(replaceIdentifiers([[

    class X extends Class1 {

      def yo { hello "world" }

    }

    new X, yo

  ]], "Class1", className(Class1))));

  // Method shadows global function (TODO)

  /*assertEqualsVerbose(6, runScript([[

    class X {

    }

    new X, j

  ]]));*/

  // Auto-"this" in initializer

  assertEqualsVerbose(6, runScript([[

    class X {

      i: int <- 5

      initializer {

        i <- i plus 1

      }

    }

    new X, i

  ]]));

  // Declare a local variable shadowing an instance field

  // with "var"

  assertEqualsVerbose(3, runScript([[

    class X {

      i: int <- 3

      def j { var i <- 5; i <- i plus 1; this }

    }

    new X, j, i

  ]]));

}