Give an error on duplicate argument names in transactions.

resources/demos/ERC20/ERC20.obs

@@ -44,7 +44,7 @@ asset interface ERC20 {
     transaction approve(int ownerAddress, int fromAddress, int value) returns bool;
 
     // Returns the amount of allowance still available.
-    transaction allowance(int ownerAddress, int ownerAddress) returns int;
+    transaction allowance(int ownerAddress, int fromAddress) returns int;
 
     // Transfers tokens from an allowance that has already been granted.
     transaction transferFrom(int senderAddress, int fromAddress, int toAddress, int value) returns bool;

resources/tests/type_checker_tests/DuplicateArgs.obs

@@ -0,0 +1,9 @@
+main contract Names {
+    // Shouldn't have duplicate names
+    transaction duplicateNames(int y, int y) {
+    }
+}
+
+interface Duplicates {
+    transaction duplicateNames(int y, int y);
+}

src/main/scala/edu/cmu/cs/obsidian/typecheck/Checker.scala

@@ -4,6 +4,8 @@ import edu.cmu.cs.obsidian.parser.Parser.Identifier
 import edu.cmu.cs.obsidian.parser._
 
 import scala.collection.immutable.TreeMap
+import scala.collection.mutable
+import scala.collection.mutable.HashSet
 
 
 /* We define a custom type to store a special flag for if a context in after a "throw".
@@ -2310,6 +2312,16 @@ class Checker(globalTable: SymbolTable, verbose: Boolean = false) {
         field
     }
 
+    private def checkDuplicateArgNames(tx: Transaction): Unit = {
+        val argNames = mutable.HashSet[String]()
+        for (arg <- tx.args) {
+            if (argNames.exists(arg.varName.equals)) {
+                logError(tx, DuplicateArgName(arg.varName))
+            }
+            argNames.add(arg.varName)
+        }
+    }
+
     private def checkTransactionInState(tx: Transaction,
                                         lexicallyInsideOf: DeclarationTable,
                                         initContext: Context): Transaction = {
@@ -2331,6 +2343,7 @@ class Checker(globalTable: SymbolTable, verbose: Boolean = false) {
             }
         }
 
+        checkDuplicateArgNames(tx);
         var context = initContext
 
         for (arg <- tx.args) {
@@ -2823,6 +2836,18 @@ class Checker(globalTable: SymbolTable, verbose: Boolean = false) {
         }
     }
 
+    private def checkInterfaceDeclaration(decl: Declaration): Unit = {
+        decl match {
+            case t: Transaction =>
+                checkDuplicateArgNames(t)
+            case s: State => ()
+            case f: Field => logError(f, FieldsNotAllowedInInterfaces(f.name, decl.name))
+            case c: Constructor => logError(c, InterfaceConstructorError())
+            case c: Contract => assert(false, "Contract nesting is no longer supported.")
+            case d: TypeDecl => assert(false, "Type declarations are not supported yet.")
+        }
+    }
+
     private def checkContract(contract: Contract): Contract = {
         currentContractSourcePath = contract.sourcePath
 
@@ -2840,7 +2865,10 @@ class Checker(globalTable: SymbolTable, verbose: Boolean = false) {
 
                 var newDecls = obsContract.declarations
 
-                if (!obsContract.isInterface) {
+                if (obsContract.isInterface) {
+                    obsContract.declarations.map(checkInterfaceDeclaration)
+                }
+                else {
                     val boundDecls = globalTable.contract(obsContract.bound.contractName) match {
                         case Some(interface) => interface.contract match {
                             case impl: ObsidianContractImpl => impl.substitute(impl.params, obsContract.bound.typeArgs).declarations

src/main/scala/edu/cmu/cs/obsidian/typecheck/Error.scala

@@ -457,7 +457,7 @@ case class PermissionCheckRedundant(actualPerm: Permission, testPermission: Perm
 
 case class AssetStateImplError(implState: State, interfaceState: State) extends Error {
     override val msg: String =
-        s"State ${implState.name} is an asset state but it implements a state which is not an asset state."
+        s"State ${implState.name} is an asset state but it implements a state that is not an asset state."
 }
 
 case class BadFFIInterfaceBoundError(name: String) extends Error {
@@ -478,4 +478,12 @@ case class StateInitializerUninitialized(stateName: String, fieldName: String) e
     override val msg: String = s"$stateName::$fieldName has not been initialized. Perhaps you are " +
         s"trying to use a field initializer for general-purpose field access instead of only for " +
         s"preparing for a transition."
+}
+
+case class DuplicateArgName(argName: String) extends Error {
+    override val msg: String = s"All argument names must be different from each other, but '$argName' occurs more than once."
+}
+
+case class FieldsNotAllowedInInterfaces(fieldName: String, interfaceName: String) extends Error {
+    override val msg: String = s"Field '$fieldName' cannot be defined on interface '$interfaceName' because interfaces cannot define fields."
 }

src/test/scala/edu/cmu/cs/obsidian/tests/TypeCheckerTests.scala

@@ -977,4 +977,11 @@ class TypeCheckerTests extends JUnitSuite {
         runTest("resources/tests/type_checker_tests/InStateOwnershipChange.obs",
             (InvalidOwnershipLossInDynamicCheck("k"), 11) :: Nil)
     }
+
+    @Test def duplicateNames(): Unit = {
+        runTest("resources/tests/type_checker_tests/DuplicateArgs.obs",
+            (DuplicateArgName("y"), 3) ::
+                (DuplicateArgName("y"), 8) ::
+                Nil)
+    }
 }