info/labs/lab03/test/resources/parser/passing/IfCondition.grading.amy

+object IfCondition
+  if (val x: Boolean = true; x) { 1 } else { 2 }
+end IfCondition

info/labs/lab03/test/resources/parser/passing/List.grading.amy

+object L
+  abstract class List
+  case class Nil() extends List
+  case class Cons(h: Int(32), t: List) extends List
+ 
+  def isEmpty(l : List): Boolean = { l match {
+    case Nil() => true
+    case _ => false 
+  }}
+
+  def length(l: List): Int(32) = { l match {
+    case Nil() => 0
+    case Cons(_, t) => 1 + length(t)
+  }}
+
+  def head(l: List): Int(32) = {
+    l match {
+      case Cons(h, _) => h
+      case Nil() => error("head(Nil)")
+    }
+  }
+
+  def headOption(l: List): O.Option = {
+    l match {
+      case Cons(h, _) => O.Some(h)
+      case Nil() => O.None()
+    }
+  }
+
+  def reverse(l: List): List = {
+    reverseAcc(l, Nil())
+  }
+
+  def reverseAcc(l: List, acc: List): List = {
+    l match {
+      case Nil() => acc
+      case Cons(h, t) => reverseAcc(t, Cons(h, acc))
+    }
+  }
+
+  def indexOf(l: List, i: Int(32)): Int(32) = {
+    l match {
+      case Nil() => -1
+      case Cons(h, t) =>
+        if (h == i) { 0 }
+        else {
+          val rec: Int(32) = indexOf(t, i);
+          if (0 <= rec) { rec + 1 }
+          else { -1 }
+        }
+    }
+  }
+
+  def range(from: Int(32), to: Int(32)): List = {
+    if (to < from) { Nil() }
+    else {
+      Cons(from, range(from + 1, to))
+    }
+  }
+
+  def sum(l: List): Int(32) = { l match {
+    case Nil() => 0
+    case Cons(h, t) => h + sum(t)
+  }}
+
+  def concat(l1: List, l2: List): List = {
+    l1 match {
+      case Nil() => l2
+      case Cons(h, t) => Cons(h, concat(t, l2))
+    }
+  }
+
+  def contains(l: List, elem: Int(32)): Boolean = { l match {
+    case Nil() =>
+      false
+    case Cons(h, t) =>
+      h == elem || contains(t, elem)
+  }}
+
+  abstract class LPair
+  case class LP(l1: List, l2: List) extends LPair
+
+  def merge(l1: List, l2: List): List = {
+    l1 match {
+      case Nil() => l2
+      case Cons(h1, t1) =>
+        l2 match {
+          case Nil() => l1
+          case Cons(h2, t2) =>
+            if (h1 <= h2) {
+              Cons(h1, merge(t1, l2))
+            } else {
+              Cons(h2, merge(l1, t2))
+            }
+        }
+    }
+  }
+
+  def split(l: List): LPair = {
+    l match {
+      case Cons(h1, Cons(h2, t)) =>
+        val rec: LPair = split(t);
+        rec match {
+          case LP(rec1, rec2) =>
+            LP(Cons(h1, rec1), Cons(h2, rec2))
+        }
+      case _ =>
+        LP(l, Nil())
+    }
+  }
+  def mergeSort(l: List): List = {
+    l match {
+      case Nil() => l
+      case Cons(h, Nil()) => l
+      case l =>
+        split(l) match {
+          case LP(l1, l2) =>
+            merge(mergeSort(l1), mergeSort(l2))
+        }
+    }
+  }
+  
+  def toString(l: List): String = { l match {
+    case Nil() => "List()"
+    case more => "List(" ++ toString1(more) ++ ")"
+  }}
+
+  def toString1(l : List): String = { l match {
+    case Cons(h, Nil()) => Std.intToString(h)
+    case Cons(h, t) => Std.intToString(h) ++ ", " ++ toString1(t)
+  }}
+
+  def take(l: List, n: Int(32)): List = {
+    if (n <= 0) { Nil() }
+    else { 
+      l match {
+        case Nil() => Nil()
+        case Cons(h, t) =>
+          Cons(h, take(t, n-1))
+      }
+    }
+  }
+end L 

info/labs/lab03/test/resources/parser/passing/Literals.amy

+object Literals
+  1; (); ( ); "Hello"; true
+end Literals

info/labs/lab03/test/resources/parser/passing/MatchScrutinee.grading.amy

+object IfMatch
+  if (true) { 1 } else { 2 } match {
+    case 1 => true
+    case 2 => false
+  }
+end IfMatch

info/labs/lab03/test/resources/parser/passing/NestedMatch.grading.amy

+object NestedMatch
+  foo match {
+    case bar => baz match {
+      case 42 => ()
+    }
+  }
+  
+end NestedMatch

info/labs/lab03/test/resources/parser/passing/Parens.grading.amy

+object Parens
+  -(!(1 + (2 * 3) / (val x: Int(32) = (42; x) ;( (x + (z match { case foo => bar }) - 3)) == (1; 2))))
+end Parens

info/labs/lab03/test/resources/parser/passing/Patterns.grading.amy

+object Patterns
+  x match {
+    case 1 => 0
+    case () => 0
+    case "" => 0
+    case "Hello" => 0
+    case true => 0
+    case false => 0
+    case x => 0
+    case Variable => 0
+    case _ => 0
+    case C() => 0
+    case C(1) => 0
+    case C(C(1)) => 0
+    case C(C(_, "", C(1, "Hello", ()), ()), D(D(_, D(3))), ()) => 0
+  }
+end Patterns

info/labs/lab03/test/resources/parser/passing/Precedence.grading.amy

+object Precedence
+  val v: Int(32) = 1 * 2 < x || y + 3;  u match { case foo => bar } ; w == -(if(x) { y } else { z })
+end Precedence

info/labs/lab03/test/resources/parser/passing/QualifiedNames.grading.amy

+object QualifiedNames
+  val x: Faz.boo = Foo.bar( x match { 
+    case Foo.baz(foo) => 1
+    case Foo.baz(Foo.bar(), foo) => 2
+  });
+  42
+end QualifiedNames

info/labs/lab03/test/scala/amyc/test/CompilerTest.scala

+package amyc.test
+
+import amyc.utils._
+import java.io.File
+
+import org.junit.Assert.fail
+
+abstract class CompilerTest extends TestUtils {
+  private def runPipeline(pipeline: Pipeline[List[File], Unit], fileNames: List[String]) = {
+    val ctx = Context(new Reporter, fileNames)
+    val files = ctx.files.map(new File(_))
+    pipeline.run(ctx)(files)
+    ctx.reporter.terminateIfErrors()
+  }
+
+  private def runPipelineRedirected(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String
+  ): String = {
+    testWithRedirectedIO(runPipeline(pipeline, compiledFiles), input)
+  }
+
+  private def assertEqual(output: String, expected: String) = {
+    val rejectLine = (s: String) =>
+      s.isEmpty ||
+        s.startsWith("[ Info  ]") ||
+        s.startsWith("[Warning]") ||
+        s.startsWith("[ Error ]") ||
+        s.startsWith("[ Fatal ]")
+    def filtered(s: String) = s.linesIterator.filterNot(rejectLine).mkString("\n")
+    val filteredOutput = filtered(output)
+    val filteredExpected = filtered(expected)
+    if (filteredOutput != filteredExpected) {
+      val sb = new StringBuffer()
+      sb.append("\nOutput is different:\n")
+      sb.append("\nOutput: \n")
+      sb.append(filteredOutput)
+      sb.append("\n\nExpected output: \n")
+      sb.append(filteredExpected)
+      sb.append("\n")
+      fail(sb.toString)
+    }
+  }
+
+  protected def compareOutputs(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    expectedFile: String,
+    input: String = ""
+  ) = {
+    try {
+      val output = runPipelineRedirected(pipeline, compiledFiles, input)
+      val expected = scala.io.Source.fromFile(new File(expectedFile)).mkString
+      assertEqual(output, expected)
+    } catch {
+      // We only want to catch AmyFatalError gracefully, the rest can propagate
+      case AmycFatalError(msg) =>
+        fail(s"\n  $msg\n")
+    }
+  }
+
+  protected def demandPass(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String = ""
+  ) = {
+    try {
+      runPipelineRedirected(pipeline, compiledFiles, input)
+    } catch {
+      case AmycFatalError(msg) =>
+        fail(s"\n  $msg\n")
+    }
+  }
+
+  protected def demandFailure(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String = ""
+  ) = {
+    try {
+      runPipelineRedirected(pipeline, compiledFiles, input)
+      fail("Test should fail but it passed!")
+    } catch {
+      case AmycFatalError(_) =>
+      // Ok, this is what we wanted. Other exceptions should propagate though
+    }
+
+  }
+
+
+}

info/labs/lab03/test/scala/amyc/test/LexerTests.scala

+package amyc.test
+
+import amyc.parsing._
+import org.junit.Test
+
+class LexerTests extends TestSuite {
+  val pipeline = AmyLexer.andThen(DisplayTokens)
+
+  val baseDir = "lexer"
+
+  val outputExt = "txt"
+
+  @Test def testKeywords = shouldOutput("Keywords")
+
+  @Test def testIdentifiers = shouldOutput("Identifiers")
+
+  @Test def testOperators = shouldOutput("Operators")
+
+  @Test def testDelimiters = shouldOutput("Delimiters")
+
+  @Test def testCombinations = shouldOutput("Combinations")
+
+  @Test def testComments = shouldOutput("Comments")
+
+  @Test def testIntLiterals = shouldOutput("IntLiterals")
+
+  @Test def testStringLiterals = shouldOutput("StringLiterals")
+
+  @Test def testTwoFiles = shouldOutput(List("Keywords", "Operators"), "TwoFiles")
+
+  @Test def testSingleAmp = shouldFail("SingleAmp")
+
+  @Test def testSingleBar = shouldFail("SingleBar")
+
+  @Test def testUnclosedComment = shouldFail("UnclosedComment")
+
+  @Test def testUnclosedComment2 = shouldFail("UnclosedComment2")
+
+  @Test def testUnclosedComment3 = shouldFail("UnclosedComment3")
+
+  @Test def testCommentClosedTwice = shouldOutput("CommentClosedTwice")
+
+  @Test def testUnclosedString1 = shouldFail("UnclosedString1")
+
+  @Test def testUnclosedString2 = shouldFail("UnclosedString2")
+
+  @Test def testInvalid = shouldFail("Invalid")
+
+  @Test def testTooBigInt = shouldFail("TooBigInt")
+
+  @Test def testWhitespace = shouldOutput("Whitespace")
+
+}

info/labs/lab03/test/scala/amyc/test/ParserTests.scala

+package amyc.test
+
+import amyc.utils._
+import amyc.ast._
+import amyc.parsing._
+import org.junit.Test
+
+class ParserTests extends TestSuite {
+
+  import NominalTreeModule.{Program => NP}
+
+  def treePrinterN(title: String): Pipeline[NP, Unit] = {
+    new Pipeline[NP, Unit] {
+      def run(ctx: Context)(v: NP) = {
+        println(title)
+        println(NominalPrinter(v))
+      }
+    }
+  }
+  val pipeline = AmyLexer.andThen(Parser).andThen(treePrinterN(""))
+
+  val baseDir = "parser"
+
+  val outputExt = "amy"
+
+  @Test def testLL1 = {
+    assert(Parser.program.isLL1)
+  }
+
+  
+  @Test def testEmpty = shouldOutput("Empty")
+
+  @Test def testErrorToken1 = shouldOutput("ErrorToken1")
+
+  @Test def testErrorToken2 = shouldOutput("ErrorToken2")
+
+  @Test def testLiterals = shouldOutput("Literals")
+
+  @Test def testPrecedence = shouldOutput("Precedence")
+
+  @Test def testAssoc = shouldOutput("Assoc")
+
+  @Test def testAssocSemicolon = shouldOutput("AssocSemicolon")
+
+  @Test def testFunDefs = shouldOutput("FunDefs")
+
+  @Test def testFunCalls = shouldOutput("FunCalls")
+
+  @Test def testClassDefs = shouldOutput("ClassDefs")
+
+  @Test def testPatterns = shouldOutput("Patterns")
+
+  @Test def testNestedMatch = shouldOutput("NestedMatch")
+
+  @Test def testParens = shouldOutput("Parens")
+
+  @Test def testQualifiedNames = shouldOutput("QualifiedNames")
+
+  @Test def testList = shouldOutput("List")
+
+  @Test def testIfCondition = shouldOutput("IfCondition")
+  @Test def testMatchScrutinee = shouldOutput("MatchScrutinee")
+  @Test def testChainedMatch = shouldOutput("ChainedMatch")
+
+  @Test def testArgsError1 = shouldFail("ArgsError1")
+  @Test def testArgsError2 = shouldFail("ArgsError2")
+  @Test def testClassDefError1 = shouldFail("ClassDefError1")
+  @Test def testClassDefError2 = shouldFail("ClassDefError2")
+  @Test def testClassDefError3 = shouldFail("ClassDefError3")
+  @Test def testClassDefError4 = shouldFail("ClassDefError4")
+  @Test def testCommentClosedTwice = shouldFail("CommentClosedTwice")
+  @Test def testEmptyFile = shouldFail("EmptyFile")
+  @Test def testFunDefError1 = shouldFail("FunDefError1")
+  @Test def testFunDefError2 = shouldFail("FunDefError2")
+  @Test def testFunDefError3 = shouldFail("FunDefError3")
+  @Test def testFunDefError4 = shouldFail("FunDefError4")
+  @Test def testFunDefError5 = shouldFail("FunDefError5")
+  @Test def testFunDefError6 = shouldFail("FunDefError6")
+  @Test def testIfPrecedence = shouldFail("IfPrecedence")
+  @Test def testIntError1 = shouldFail("IntError1")
+  @Test def testIntError2 = shouldFail("IntError2")
+  @Test def testIntError3 = shouldFail("IntError3")
+  @Test def testTypeWidth = shouldFail("TypeWidth")
+  @Test def testMatchAsOperand = shouldFail("MatchAsOperand")
+  @Test def testMissingOperand = shouldFail("MissingOperand")
+  @Test def testUnaryWithinUnary = shouldFail("UnaryWithinUnary")
+  @Test def testUnmatchedModule = shouldFail("UnmatchedModule")
+  @Test def testUnmatchedModuleName = shouldFail("UnmatchedModuleName")
+  @Test def testUnmatchedParen = shouldFail("UnmatchedParen")
+  @Test def testValAsOperand = shouldFail("ValAsOperand")
+  @Test def testValError = shouldFail("ValError")
+  @Test def testValInVal = shouldFail("ValInVal")
+  @Test def testWrongQName1 = shouldFail("WrongQName1")
+  @Test def testWrongQName2 = shouldFail("WrongQName2")
+  @Test def testWrongQName3 = shouldFail("WrongQName3")
+  @Test def testWrongQName4 = shouldFail("WrongQName4")
+
+}

info/labs/lab03/test/scala/amyc/test/TestSuite.scala

+package amyc.test
+
+import amyc.utils.Pipeline
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+
+abstract class TestSuite extends CompilerTest {
+  val pipeline: Pipeline[List[File], Unit]
+
+  val baseDir: String
+  lazy val effectiveBaseDir: String =
+    // getClass.getResource(s"/$baseDir").getPath
+    s"test/resources/$baseDir"
+
+  val passing = "passing"
+  val failing = "failing"
+  val outputs = "outputs"
+
+  val tmpDir = Files.createTempDirectory("amyc");
+
+  val outputExt: String
+
+  def getResourcePath(relativePath: String, otherPath: Option[String] = None): String =
+    val firstPath = Path.of(effectiveBaseDir, relativePath)
+
+    val (stream, path) = 
+      if Files.exists(firstPath) then
+        (Files.newInputStream(firstPath), relativePath)
+      else
+        otherPath match
+          case Some(p) =>
+            val secondPath = Path.of(effectiveBaseDir, p)
+            (Files.newInputStream(secondPath), p)
+          case None =>
+            assert(false, s"can not read $effectiveBaseDir/$relativePath")
+            (null, "")
+
+    val targetPath = tmpDir.resolve(path)
+    Files.createDirectories(targetPath.getParent())
+    Files.copy(stream, targetPath, StandardCopyOption.REPLACE_EXISTING)
+    targetPath.toAbsolutePath().toString()
+
+  def shouldOutput(inputFiles: List[String], outputFile: String, input: String = ""): Unit = {
+    compareOutputs(
+      pipeline,
+      inputFiles map (f => getResourcePath(s"$passing/$f.amy", Some(s"$passing/$f.grading.amy"))),
+      getResourcePath(s"$outputs/$outputFile.$outputExt", Some(s"$outputs/$outputFile.grading.$outputExt")),
+      input
+    )
+  }
+
+  def shouldOutput(inputFile: String): Unit = {
+    shouldOutput(List(inputFile), inputFile)
+  }
+
+  def shouldFail(inputFiles: List[String], input: String = ""): Unit = {
+    demandFailure(
+      pipeline,
+      inputFiles map (f => getResourcePath(s"$failing/$f.amy", Some(s"$failing/$f.grading.amy"))),
+      input
+    )
+  }
+
+  def shouldFail(inputFile: String): Unit = {
+    shouldFail(List(inputFile))
+  }
+
+  def shouldPass(inputFiles: List[String], input: String = ""): Unit = {
+    demandPass(pipeline, inputFiles map (f => getResourcePath(s"$passing/$f.amy", Some(s"$passing/$f.grading.amy"))), input)
+  }
+
+  def shouldPass(inputFile: String): Unit = {
+    shouldPass(List(inputFile))
+  }
+
+}

info/labs/lab03/test/scala/amyc/test/TestUtils.scala

+package amyc.test
+
+import java.io._
+
+/** Some utilities for running tests */
+trait TestUtils {
+  /** Run test,
+    * with input also redirected from a String,
+    * and output is redirected to a local StringBuilder.
+    */
+  def testWithRedirectedIO[T](test: => T, input: String): String = {
+    import scala.Console._
+    val inputS  = new StringReader(input)
+    val outputS = new ByteArrayOutputStream()
+    withOut(outputS) {
+      withErr(outputS) {
+        withIn(inputS) {
+          test
+        }
+      }
+    }
+    outputS.toString()
+  }
+}

info/labs/lab04/amyi.sh

+#!/bin/bash
+# Script similar in structure to amytc.sh, see explanations there.
+if [ $# -eq 0 ]; then
+    echo "Usage: amyi Prog1.amy Prog2.amy ... ProgN.amy"
+    exit 1
+fi
+echo Intepreting: $*
+AMYJAR=target/scala-3.5.2/amyc-assembly-1.7.jar
+if test -r "${AMYJAR}"; then
+    echo "Reusing existing jar: ${AMYJAR}"
+else
+    sbt assembly
+fi
+java -jar ${AMYJAR} --interpret library/Std.amy library/Option.amy library/List.amy $*

info/labs/lab04/amytc.sh

+#!/bin/bash
+# The above line tells the operating system to use the 
+# bash shell interpreter to execute the commands in this file.
+# the hash sign, '#' means that characters following it are comments
+if [ $# -eq 0 ]; then # script is called with 0 parameters
+    # output short usage instructions on the command line
+    echo "Usage: amytc.sh Prog1.amy Prog2.amy ... ProgN.amy"
+    echo "Example invocation:"
+    echo "./amytc.sh examples/Arithmetic.amy"
+
+    echo "Example output:"
+    echo "  Type checking: examples/Arithmetic.amy"
+    echo "  Reusing existing jar: target/scala-3.5.2/amyc-assembly-1.7.jar"
+    echo "  Type checking successful!"
+    # Now, terminate the script with an error exit code 1:
+    exit 1
+fi
+# print progress message. $* denotes all arguments
+echo Type checking: $*
+# jar file is a zip file containing .class files of our interpreter/compiler
+# sbt generates the file in this particular place.
+AMYJAR=target/scala-3.5.2/amyc-assembly-1.7.jar
+# You can copy this file into test.zip and run unzip test.zip to see inside
+if test -r "${AMYJAR}"; then
+    # jar file exists, so we just reuse it
+    echo "Reusing existing jar: ${AMYJAR}"
+    # Note that we do not check if scala sources changed!
+    # Hence, our jar file can be old
+else
+    # If there is no jar file, we invoke `sbt assembly` to create it
+    sbt assembly
+fi
+# We should have the jar file now, so we invoke it
+# java starts the Java Virtual Machine. 
+# Here, it will unpack the jar file and find META-INF/MANIFEST.MF file
+# which specifies the main class of the jar file (entry point).
+# java will execute `public static void main` method of that class.
+java -jar ${AMYJAR} --type-check library/Std.amy library/Option.amy library/List.amy $*
+# Here, we ask amy to only type check the give files. 
+# We always provide standard library files as well as 
+# the explicitly files explicit given to the script (denoted $*)

info/labs/lab04/build.sbt

+version := "1.7"
+organization := "ch.epfl.lara"
+scalaVersion := "3.5.2"
+assembly / test := {}
+name := "amyc"
+
+Compile / scalaSource := baseDirectory.value / "src"
+scalacOptions ++= Seq("-feature")
+
+Test / scalaSource := baseDirectory.value / "test" / "scala"
+Test / parallelExecution := false
+libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % "test"
+libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.4" % "test"
+testOptions += Tests.Argument(TestFrameworks.JUnit, "-v")
+
+
+assembly / assemblyMergeStrategy  := {
+  {
+    case _ => MergeStrategy.first
+  }
+}

info/labs/lab04/examples/Arithmetic.amy

+object Arithmetic
+  def pow(b: Int(32), e: Int(32)): Int(32) = {
+    if (e == 0) { 1 }
+    else {
+      if (e % 2 == 0) {
+        val rec: Int(32) = pow(b, e/2);
+        rec * rec
+      } else {
+        b * pow(b, e - 1)
+      }
+    }
+  }
+
+  def gcd(a: Int(32), b: Int(32)): Int(32) = {
+    if (a == 0 || b == 0) {
+      a + b
+    } else {
+      if (a < b) {
+        gcd(a, b % a)
+      } else {
+        gcd(a % b, b)
+      }
+    }
+  }
+
+  Std.printInt(pow(0, 10));
+  Std.printInt(pow(1, 5));
+  Std.printInt(pow(2, 10));
+  Std.printInt(pow(3, 3));
+  Std.printInt(gcd(0, 10));
+  Std.printInt(gcd(17, 99)); // 1
+  Std.printInt(gcd(16, 46)); // 2
+  Std.printInt(gcd(222, 888)) // 222
+end Arithmetic

info/labs/lab04/examples/Factorial.amy

+object Factorial
+  def fact(i: Int(32)): Int(32) = {
+    if (i < 2) { 1 }
+    else { 
+      val rec: Int(32) = fact(i-1);
+      i * rec
+    }
+  }
+
+  Std.printString("5! = "  ++ Std.intToString(fact(5)));
+  Std.printString("10! = " ++ Std.intToString(fact(10)))
+end Factorial

info/labs/lab04/examples/Hanoi.amy

+object Hanoi
+	
+  def solve(n : Int(32)) : Int(32) = {
+    if (n < 1) { 
+      error("can't solve Hanoi for less than 1 plate")
+    } else {
+      if (n == 1) {
+        1
+      } else {
+        2 * solve(n - 1) + 1
+      }
+    }
+  }
+
+  Std.printString("Hanoi for 4 plates: " ++ Std.intToString(solve(4)))
+end Hanoi
\ No newline at end of file