Check native function declarations

runtime/sema/check_function.go

@@ -76,6 +76,21 @@ func (checker *Checker) visitFunctionDeclaration(
 		declaration.Identifier,
 	)
 
+	functionBlock := declaration.FunctionBlock
+
+	if declaration.IsNative() {
+		if !functionBlock.IsEmpty() {
+			checker.report(&NativeFunctionWithImplementationError{
+				Range: ast.NewRangeFromPositioned(
+					checker.memoryGauge,
+					functionBlock,
+				),
+			})
+		}
+
+		functionBlock = nil
+	}
+
 	// global functions were previously declared, see `declareFunctionDeclaration`
 
 	functionType := checker.Elaboration.FunctionDeclarationFunctionType(declaration)
@@ -93,7 +108,7 @@ func (checker *Checker) visitFunctionDeclaration(
 		declaration.ParameterList,
 		declaration.ReturnTypeAnnotation,
 		functionType,
-		declaration.FunctionBlock,
+		functionBlock,
 		options.mustExit,
 		nil,
 		options.checkResourceLoss,

runtime/sema/errors.go

@@ -878,6 +878,23 @@ func (e *InvalidNativeModifierError) Error() string {
 	return "invalid native modifier for declaration"
 }
 
+// NativeFunctionWithImplementationError
+
+type NativeFunctionWithImplementationError struct {
+	ast.Range
+}
+
+var _ SemanticError = &NativeFunctionWithImplementationError{}
+var _ errors.UserError = &NativeFunctionWithImplementationError{}
+
+func (*NativeFunctionWithImplementationError) isSemanticError() {}
+
+func (*NativeFunctionWithImplementationError) IsUserError() {}
+
+func (e *NativeFunctionWithImplementationError) Error() string {
+	return "native function may not have an implementation"
+}
+
 // InvalidNameError
 
 type InvalidNameError struct {

runtime/tests/checker/function_test.go

@@ -440,20 +440,74 @@ func TestCheckNativeFunctionDeclaration(t *testing.T) {
 
 	t.Parallel()
 
-	_, err := ParseAndCheckWithOptions(t,
-		`
-          native fun test() {}
-        `,
-		ParseAndCheckOptions{
-			ParseOptions: parser.Config{
-				NativeModifierEnabled: true,
+	t.Run("disabled", func(t *testing.T) {
+
+		t.Parallel()
+
+		_, err := ParseAndCheckWithOptions(t,
+			`
+              native fun test(): Int {}
+            `,
+			ParseAndCheckOptions{
+				ParseOptions: parser.Config{
+					NativeModifierEnabled: true,
+				},
+				Config: &sema.Config{
+					AllowNativeDeclarations: false,
+				},
 			},
-		},
-	)
+		)
 
-	errs := RequireCheckerErrors(t, err, 1)
+		errs := RequireCheckerErrors(t, err, 1)
+
+		assert.IsType(t, &sema.InvalidNativeModifierError{}, errs[0])
+	})
+
+	t.Run("enabled, valid", func(t *testing.T) {
+
+		t.Parallel()
+
+		_, err := ParseAndCheckWithOptions(t,
+			`
+              native fun test(): Int {}
+            `,
+			ParseAndCheckOptions{
+				ParseOptions: parser.Config{
+					NativeModifierEnabled: true,
+				},
+				Config: &sema.Config{
+					AllowNativeDeclarations: true,
+				},
+			},
+		)
+
+		require.NoError(t, err)
+	})
+
+	t.Run("enabled, invalid", func(t *testing.T) {
 
-	assert.IsType(t, &sema.InvalidNativeModifierError{}, errs[0])
+		t.Parallel()
+
+		_, err := ParseAndCheckWithOptions(t,
+			`
+              native fun test(): Int {
+                  return 1
+              }
+            `,
+			ParseAndCheckOptions{
+				ParseOptions: parser.Config{
+					NativeModifierEnabled: true,
+				},
+				Config: &sema.Config{
+					AllowNativeDeclarations: true,
+				},
+			},
+		)
+
+		errs := RequireCheckerErrors(t, err, 1)
+
+		assert.IsType(t, &sema.NativeFunctionWithImplementationError{}, errs[0])
+	})
 }
 
 func TestCheckResultVariable(t *testing.T) {