Semantic: disallow named arguments in fn & method calls

src/semantic/expr.ts

@@ -443,6 +443,11 @@ export const checkCall = (unaryExpr: UnaryExpr, ctx: Context): void => {
     if (variantRef) {
         unaryExpr.type = checkVariantCall(unaryExpr, variantRef, ctx)
     } else {
+        call.args
+            .filter(arg => arg.name !== undefined)
+            .forEach(arg =>
+                addError(ctx, semanticError(ctx, arg.name!, `unexpected named argument \`${arg.name!.value}\``))
+            )
         unaryExpr.type = checkCall_(call, operand, args, ctx)
     }
 }
@@ -525,14 +530,14 @@ export const checkCall_ = (call: CallOp, operand: Operand, args: Expr[], ctx: Co
     }
 
     const fnType = <VirtualFnType>operand.type
+
     const genericMaps = makeFnGenericMaps(
         operand.kind === 'identifier' ? operand.typeArgs.map(tp => typeToVirtual(tp, ctx)) : [],
         fnType,
         args.map(a => a.type!),
         ctx
     )
     const paramTypes = fnType.paramTypes.map(pt => resolveType(pt, genericMaps, ctx))
-    // TODO: if it is a vid type call without args (e.g. Option::Some()), use checkNamedCall() reporting
     checkCallArgs(call, args, paramTypes, ctx)
 
     call.generics = fnType.generics.map(g => {

src/semantic/instance.ts

@@ -117,7 +117,12 @@ const checkMethodCallExpr = (
     if (binaryExpr.type) return binaryExpr.type
 
     checkOperand(lOperand, ctx)
-    call.args.forEach(a => checkExpr(a.expr, ctx))
+    call.args.forEach(arg => {
+        checkExpr(arg.expr, ctx)
+        if (arg.name) {
+            addError(ctx, semanticError(ctx, arg.name, `unexpected named argument \`${arg.name!.value}\``))
+        }
+    })
 
     const namedArgs = call.args.filter(a => a.name)
     namedArgs.forEach(arg => {

src/semantic/semantic.spec.ts

@@ -659,6 +659,16 @@ fn main() {
             ])
         })
 
+        it('fn named call', () => {
+            const code = `\
+fn main() {
+    let foo = println(value: 5)
+    return unit
+}`
+            const ctx = check(code)
+            expect(ctx.errors.map(e => e.message)).toEqual(['unexpected named argument `value`'])
+        })
+
         it('wrong arg count', () => {
             const code = (arg: string) => `\
 type Foo(x: Int)