Various regression tests

runtime/convertValues_test.go

@@ -2099,25 +2099,27 @@ func TestRuntimeEnumValue(t *testing.T) {
 }
 
 func executeTestScript(t *testing.T, script string, arg cadence.Value) (cadence.Value, error) {
-	encodedArg, err := json.Encode(arg)
-	require.NoError(t, err)
-
 	rt := newTestInterpreterRuntime()
 
-	storage := newTestLedger(nil, nil)
-
 	runtimeInterface := &testRuntimeInterface{
-		storage: storage,
+		storage: newTestLedger(nil, nil),
 		decodeArgument: func(b []byte, t cadence.Type) (value cadence.Value, err error) {
 			return json.Decode(b)
 		},
 	}
 
+	scriptParam := Script{
+		Source: []byte(script),
+	}
+
+	if arg != nil {
+		encodedArg, err := json.Encode(arg)
+		require.NoError(t, err)
+		scriptParam.Arguments = [][]byte{encodedArg}
+	}
+
 	return rt.ExecuteScript(
-		Script{
-			Source:    []byte(script),
-			Arguments: [][]byte{encodedArg},
-		},
+		scriptParam,
 		Context{
 			Interface: runtimeInterface,
 			Location:  TestLocation,

runtime/parser2/parser_test.go

@@ -37,11 +37,28 @@ func TestMain(m *testing.M) {
 }
 
 func TestParseInvalid(t *testing.T) {
-
 	t.Parallel()
 
-	_, err := ParseProgram("X")
-	require.EqualError(t, err, "Parsing failed:\nerror: unexpected token: identifier\n --> :1:0\n  |\n1 | X\n  | ^\n")
+	type test struct {
+		msg  string
+		code string
+	}
+
+	unexpectedToken := "Parsing failed:\nerror: unexpected token: identifier"
+	expectedExpression := "Parsing failed:\nerror: expected expression"
+	missingTypeAnnotation := "Parsing failed:\nerror: missing type annotation after comma"
+
+	for _, test := range []test{
+		{unexpectedToken, "X"},
+		{unexpectedToken, "paste your code in here"},
+		{expectedExpression, "# a ( b > c > d > e > f > g > h > i > j > k > l > m > n > o > p > q > r > s > t > u > v > w > x > y > z > A > B > C > D > E > F>"},
+		{missingTypeAnnotation, "#0x0<{},>()"},
+	} {
+		t.Run(test.code, func(t *testing.T) {
+			_, err := ParseProgram(test.code)
+			require.ErrorContains(t, err, test.msg)
+		})
+	}
 }
 
 func TestParseBuffering(t *testing.T) {

runtime/tests/checker/casting_test.go

@@ -6676,3 +6676,24 @@ func TestCheckUnnecessaryCasts(t *testing.T) {
 		})
 	})
 }
+
+func TestCastResourceAsEnumAsEmptyDict(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "resource as { enum x : as { } }")
+
+	errs := ExpectCheckerErrors(t, err, 2)
+
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0])
+	assert.IsType(t, &sema.InvalidEnumRawTypeError{}, errs[1])
+}
+
+//
+
+func TestCastNumbersManyTimesThenGetType(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "let a = 0x0 as UInt64!as?UInt64!as?UInt64?!?.getType()")
+
+	assert.Nil(t, err)
+}

runtime/tests/checker/contract_test.go

@@ -708,3 +708,43 @@ func TestCheckInvalidContractNestedTypeShadowing(t *testing.T) {
 		})
 	}
 }
+
+func TestCheckBadContractNesting(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "contract signatureAlgorithm { resource interface payer { contract fun : payer { contract fun { contract fun { } contract fun { contract interface account { } } contract account { } } } } }")
+
+	errs := ExpectCheckerErrors(t, err, 14)
+
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[2])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[3])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[4])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[5])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[6])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[7])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[8])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[9])
+	assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[10])
+	assert.IsType(t, &sema.MissingConformanceError{}, errs[11])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[12])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[13])
+}
+
+func TestCheckContractEnumAccessRestricted(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheckWithOptions(t, "contract enum{}let x = enum!",
+		ParseAndCheckOptions{
+			Options: []sema.Option{
+				sema.WithAccessCheckMode(sema.AccessCheckModeStrict),
+			},
+		},
+	)
+
+	errs := ExpectCheckerErrors(t, err, 2)
+
+	assert.IsType(t, &sema.MissingAccessModifierError{}, errs[0])
+	assert.IsType(t, &sema.MissingAccessModifierError{}, errs[1])
+}

runtime/tests/checker/declaration_test.go

@@ -677,3 +677,37 @@ func TestCheckBuiltinRedeclaration(t *testing.T) {
 		},
 	)
 }
+
+func TestCheckUint64RedeclarationFails(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "let UInt64 = UInt64 ( 0b0 )")
+
+	errs := ExpectCheckerErrors(t, err, 1)
+
+	assert.IsType(t, &sema.RedeclarationError{}, errs[0])
+}
+
+func TestCheckTypeRedeclarationFails(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "let Type = Type")
+
+	errs := ExpectCheckerErrors(t, err, 1)
+
+	assert.IsType(t, &sema.RedeclarationError{}, errs[0])
+}
+
+func TestCheckSetToTypeList(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "var a=[Type]")
+	assert.Nil(t, err)
+}
+
+func TestCheckSetToDictWithType(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "var j={0.0:Type}")
+	assert.Nil(t, err)
+}

runtime/tests/checker/interface_test.go

@@ -1991,3 +1991,24 @@ func TestCheckInvalidInterfaceUseAsTypeSuggestion(t *testing.T) {
 		errs[0].(*sema.InvalidInterfaceTypeError).ExpectedType,
 	)
 }
+
+func TestCheckBadStructInterface(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "struct interface var { contract h : var { contract h { } contract h { contract h { } } } }")
+
+	errs := ExpectCheckerErrors(t, err, 12)
+
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[2])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[3])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[4])
+	assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[5])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[6])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[7])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[8])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[9])
+	assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[10])
+	assert.IsType(t, &sema.RedeclarationError{}, errs[11])
+}

runtime/tests/checker/nesting_test.go

@@ -323,3 +323,13 @@ func TestCheckNestedTypeInvalidChildType(t *testing.T) {
 		})
 	}
 }
+
+func TestCheckNestedTypeUnsupportedPublicKey(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseAndCheck(t, "let b=0.0as!PublicKey.Contracts")
+
+	errs := ExpectCheckerErrors(t, err, 1)
+
+	assert.IsType(t, &sema.InvalidNestedTypeError{}, errs[0])
+}

runtime/tests/checker/resources_test.go

@@ -8616,3 +8616,64 @@ func TestCheckResourceInvalidationWithConditionalExprInDestroy(t *testing.T) {
 	assert.IsType(t, &sema.InvalidConditionalResourceOperandError{}, errs[0])
 	assert.IsType(t, &sema.InvalidConditionalResourceOperandError{}, errs[1])
 }
+
+func TestCheckBadResourceInterface(t *testing.T) {
+	t.Parallel()
+
+	t.Run("bad resource interface: shorter", func(t *testing.T) {
+
+		_, err := ParseAndCheck(t, "resource interface struct{struct d:struct{ struct d:struct{ }struct d:struct{ struct d:struct{ }}}}")
+
+		errs := ExpectCheckerErrors(t, err, 17)
+
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0])
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[2])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[3])
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[4])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[5])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[6])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[7])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[8])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[9])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[10])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[11])
+		assert.IsType(t, &sema.ConformanceError{}, errs[12])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[13])
+		assert.IsType(t, &sema.ConformanceError{}, errs[14])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[15])
+		assert.IsType(t, &sema.ConformanceError{}, errs[16])
+	})
+
+	t.Run("bad resource interface: longer", func(t *testing.T) {
+
+		_, err := ParseAndCheck(t, "resource interface struct{struct d:struct{ contract d:struct{ contract x:struct{ struct d{} contract d:struct{ contract d:struct {}}}}}}")
+
+		errs := ExpectCheckerErrors(t, err, 24)
+
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0])
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[2])
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[3])
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[4])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[5])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[6])
+		assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[7])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[8])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[9])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[10])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[11])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[12])
+		assert.IsType(t, &sema.ConformanceError{}, errs[13])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[14])
+		assert.IsType(t, &sema.ConformanceError{}, errs[15])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[16])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[17])
+		assert.IsType(t, &sema.RedeclarationError{}, errs[18])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[19])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[20])
+		assert.IsType(t, &sema.ConformanceError{}, errs[21])
+		assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[22])
+		assert.IsType(t, &sema.ConformanceError{}, errs[23])
+	})
+}