diff --git a/src/main/wacc/Main.scala b/src/main/wacc/Main.scala
index 3d16c33..68688bc 100644
--- a/src/main/wacc/Main.scala
+++ b/src/main/wacc/Main.scala
@@ -18,6 +18,7 @@ import org.typelevel.log4cats.Logger
 
 import assemblyIR as asm
 import cats.data.ValidatedNel
+import java.io.File
 
 /*
 TODO:
@@ -68,11 +69,12 @@ val outputOpt: Opts[Option[Path]] =
     .orNone
 
 def frontend(
-    contents: String
+    contents: String, file: File
 ): Either[NonEmptyList[Error], microWacc.Program] =
   parser.parse(contents) match {
     case Failure(msg) => Left(NonEmptyList.one(Error.SyntaxError(msg)))
-    case Success(ast.PartialProgram(_, prog)) =>
+    case Success(fn) =>
+      val ast.PartialProgram(_, prog) = fn(file)
       given errors: mutable.Builder[Error, List[Error]] = List.newBuilder
 
       val (names, funcs) = renamer.rename(prog)
@@ -105,8 +107,8 @@ def compile(
     writer.writeTo(backend(typedProg), outputPath) *>
       logger.info(s"Success: ${outputPath.toAbsolutePath}")
 
-  def processProgram(contents: String, outDir: Path): IO[Int] =
-    frontend(contents) match {
+  def processProgram(contents: String, file: File, outDir: Path): IO[Int] =
+    frontend(contents, file) match {
       case Left(errors) =>
         val code = errors.map(err => err.exitCode).toList.min
         given errorContent: String = contents
@@ -127,7 +129,7 @@ def compile(
   for {
     contents <- readSourceFile
     _ <- logAction(s"Compiling file: ${filePath.toAbsolutePath}")
-    exitCode <- processProgram(contents, outputDir.getOrElse(filePath.getParent))
+    exitCode <- processProgram(contents, filePath.toFile, outputDir.getOrElse(filePath.getParent))
   } yield exitCode
 }
 
diff --git a/src/main/wacc/frontend/parser.scala b/src/main/wacc/frontend/parser.scala
index 9f3fa40..3b8ead4 100644
--- a/src/main/wacc/frontend/parser.scala
+++ b/src/main/wacc/frontend/parser.scala
@@ -1,10 +1,11 @@
 package wacc
 
+import java.io.File
 import parsley.Result
 import parsley.Parsley
 import parsley.Parsley.{atomic, many, notFollowedBy, pure, unit}
 import parsley.combinator.{countSome, sepBy, option}
-import parsley.expr.{precedence, SOps, InfixL, InfixN, InfixR, Prefix, Atoms}
+import parsley.expr.{precedence, SOps, InfixL, InfixN, /*InfixR,*/ Prefix, Atoms}
 import parsley.errors.combinator._
 import parsley.errors.patterns.VerifiedErrors
 import parsley.syntax.zipped._
@@ -52,13 +53,30 @@ object parser {
   implicit val builder: ErrorBuilder[String] = new DefaultErrorBuilder with LexToken {
     def tokens = errTokens
   }
-  def parse(input: String): Result[String, PartialProgram] = parser.parse(input)
+  def parse(input: String): Result[String, File => PartialProgram] = parser.parse(input)
   private val parser = lexer.fully(`<partial-program>`)
 
+  private type FParsley[A] = Parsley[File => A]
+
+  private def fParsley[A](p: Parsley[A]): FParsley[A] =
+    p map { a => file => a }
+
+  private def fList[A](p: Parsley[List[File => A]]): FParsley[List[A]] =
+    p map { l => file => l.map(_(file)) }
+
+  private def fNonEmptyList[A](p: Parsley[NonEmptyList[File => A]]): FParsley[NonEmptyList[A]] =
+    p map { l => file => l.map(_(file)) }
+
+  private def fPair[A, B](p: Parsley[(File => A, File => B)]): FParsley[(A, B)] =
+    p map { case (a, b) => file => (a(file), b(file)) }
+
+  private def fOption[A](p: Parsley[Option[File => A]]): FParsley[Option[A]] =
+    p map { l => file => l.map(_(file)) }
+
   // Expressions
-  private lazy val `<expr>`: Parsley[Expr] = precedence {
-    SOps(InfixR)(Or from "||") +:
-      SOps(InfixR)(And from "&&") +:
+  private lazy val `<expr>`: FParsley[Expr] = precedence {
+    // SOps(InfixR)(Or from "||") +:
+    //   SOps(InfixR)(And from "&&") +:
       SOps(InfixN)(Eq from "==", Neq from "!=") +:
       SOps(InfixN)(
         Less from "<",
@@ -83,7 +101,7 @@ object parser {
   }
 
   // Atoms
-  private lazy val `<atom>`: Atoms[Expr6] = Atoms(
+  private lazy val `<atom>`: Atoms[File => Expr6] = Atoms(
     IntLiter(integer).label("integer literal"),
     BoolLiter(("true" as true) | ("false" as false)).label("boolean literal"),
     CharLiter(charLit).label("character literal"),
@@ -92,24 +110,24 @@ object parser {
     `<ident-or-array-elem>`,
     Parens("(" ~> `<expr>` <~ ")")
   )
-  private val `<str-liter>` = StrLiter(stringLit)
-  private val `<ident>` =
+  private lazy val `<str-liter>` = StrLiter(stringLit)
+  private lazy val `<ident>` =
     Ident(ident) | some("*" | "&").verifiedExplain("pointer operators are not allowed")
   private lazy val `<ident-or-array-elem>` =
     (`<ident>` <~ ("(".verifiedExplain(
       "functions can only be called using 'call' keyword"
     ) | unit)) <**> (`<array-indices>` </> identity)
-  private val `<array-indices>` = ArrayElem(some("[" ~> `<expr>` <~ "]"))
+  private lazy val `<array-indices>` = ArrayElem(fNonEmptyList(some("[" ~> `<expr>` <~ "]")))
 
   // Types
-  private lazy val `<type>`: Parsley[Type] =
+  private lazy val `<type>`: FParsley[Type] =
     (`<base-type>` | (`<pair-type>` ~> `<pair-elems-type>`)) <**> (`<array-type>` </> identity)
   private val `<base-type>` =
     (IntType from "int") | (BoolType from "bool") | (CharType from "char") | (StringType from "string")
   private lazy val `<array-type>` =
-    ArrayType(countSome("[" ~> "]"))
+    ArrayType(fParsley(countSome("[" ~> "]")))
   private val `<pair-type>` = "pair"
-  private val `<pair-elems-type>`: Parsley[PairType] = PairType(
+  private val `<pair-elems-type>`: FParsley[PairType] = PairType(
     "(" ~> `<pair-elem-type>` <~ ",",
     `<pair-elem-type>` <~ ")"
   )
@@ -117,7 +135,7 @@ object parser {
     (`<base-type>` <**> (`<array-type>` </> identity)) |
       ((UntypedPairType from `<pair-type>`) <**>
         ((`<pair-elems-type>` <**> `<array-type>`)
-          .map(arr => (_: UntypedPairType) => arr) </> identity))
+          .map(arr => (_: File => UntypedPairType) => arr) </> identity))
 
   /* Statements
     Atomic is used in two places here:
@@ -129,25 +147,25 @@ object parser {
         concern.
    */
   private lazy val `<partial-program>` = PartialProgram(
-    many(`<import>`),
+    fList(many(`<import>`)),
     `<program>`
   )
   private lazy val `<import>` = Import(
     "import" ~> `<import-filename>`,
-    "(" ~> sepBy1(`<imported-func>`, ",") <~ ")"
+    "(" ~> fNonEmptyList(sepBy1(`<imported-func>`, ",")) <~ ")"
   )
   private lazy val `<import-filename>` = `<str-liter>`.label("import file name")
   private lazy val `<imported-func>` = ImportedFunc(
     `<ident>`.label("imported function name"),
-    option("as" ~> `<ident>`).label("imported function alias")
+    fOption(option("as" ~> `<ident>`)).label("imported function alias")
   )
   private lazy val `<program>` = Program(
     "begin" ~> (
-      many(
-        atomic(
+      fList(many(
+        fPair(atomic(
           `<type>`.label("function declaration") <~> `<ident>` <~ "("
-        ) <**> `<partial-func-decl>`
-      ).label("function declaration") |
+        )) <**> `<partial-func-decl>`
+      ).label("function declaration")) |
         atomic(`<ident>` <~ "(").verifiedExplain("function declaration is missing return type")
     ),
     `<stmt>`.label(
@@ -156,17 +174,18 @@ object parser {
   )
   private lazy val `<partial-func-decl>` =
     FuncDecl(
-      sepBy(`<param>`, ",") <~ ")" <~ "is",
-      `<stmt>`.guardAgainst {
-        case stmts if !stmts.isReturning => Seq("all functions must end in a returning statement")
-      } <~ "end"
+      fPair((fList(sepBy(`<param>`, ",")) <~ ")" <~ "is") <~>
+      (`<stmt>`.guardAgainst {
+        // TODO: passing in an arbitrary file works but is ugly
+        case stmts if !(stmts(File("."))).isReturning => Seq("all functions must end in a returning statement")
+      } <~ "end"))
     )
   private lazy val `<param>` = Param(`<type>`, `<ident>`)
-  private lazy val `<stmt>`: Parsley[NonEmptyList[Stmt]] =
-    (
+  private lazy val `<stmt>`: FParsley[NonEmptyList[Stmt]] =
+    fNonEmptyList((
       `<basic-stmt>`.label("main program body"),
       (many(";" ~> `<basic-stmt>`.label("statement after ';'"))) </> Nil
-    ).zipped(NonEmptyList.apply)
+    ).zipped(NonEmptyList.apply))
 
   private lazy val `<basic-stmt>` =
     (Skip from "skip")
@@ -174,8 +193,8 @@ object parser {
       | Free("free" ~> `<expr>`.labelAndExplain(LabelType.Expr))
       | Return("return" ~> `<expr>`.labelAndExplain(LabelType.Expr))
       | Exit("exit" ~> `<expr>`.labelAndExplain(LabelType.Expr))
-      | Print("print" ~> `<expr>`.labelAndExplain(LabelType.Expr), pure(false))
-      | Print("println" ~> `<expr>`.labelAndExplain(LabelType.Expr), pure(true))
+      | Print("print" ~> `<expr>`.labelAndExplain(LabelType.Expr), fParsley(pure(false)))
+      | Print("println" ~> `<expr>`.labelAndExplain(LabelType.Expr), fParsley(pure(true)))
       | If(
         "if" ~> `<expr>`.labelWithType(LabelType.Expr) <~ "then",
         `<stmt>` <~ "else",
@@ -199,9 +218,9 @@ object parser {
       ("call" ~> `<ident>`).verifiedExplain(
         "function calls' results must be assigned to a variable"
       )
-  private lazy val `<lvalue>`: Parsley[LValue] =
+  private lazy val `<lvalue>`: FParsley[LValue] =
     `<pair-elem>` | `<ident-or-array-elem>`
-  private lazy val `<rvalue>`: Parsley[RValue] =
+  private lazy val `<rvalue>`: FParsley[RValue] =
     `<array-liter>` |
       NewPair(
         "newpair" ~> "(" ~> `<expr>` <~ ",",
@@ -210,13 +229,13 @@ object parser {
       `<pair-elem>` |
       Call(
         "call" ~> `<ident>` <~ "(",
-        sepBy(`<expr>`, ",") <~ ")"
+        fList(sepBy(`<expr>`, ",")) <~ ")"
       ) | `<expr>`.labelWithType(LabelType.Expr)
   private lazy val `<pair-elem>` =
     Fst("fst" ~> `<lvalue>`.label("valid pair"))
       | Snd("snd" ~> `<lvalue>`.label("valid pair"))
   private lazy val `<array-liter>` = ArrayLiter(
-    "[" ~> sepBy(`<expr>`, ",") <~ "]"
+    "[" ~> fList(sepBy(`<expr>`, ",")) <~ "]"
   )
 
   extension (stmts: NonEmptyList[Stmt]) {