add some "no invalidations" tests

Test that adding certain type-method pairs doesn't cause any
invalidation.

Currently the new type subtypes `Integer` in all cases.

Some of the tests are marked as broken.

Merging this will make the contribution process more demanding: when
someone makes a PR they might need to fix unrelated type stability
issues, or decrease `max_methods` for some function before being able
to merge their initial PR. However that's better than ignoring the
constant danger of type instability/invalidation regressions making the
sysimage and precompilation less useful.

Author: nsajko

test/choosetests.jl

@@ -16,7 +16,7 @@ const TESTNAMES = [
         "operators", "ordering", "path", "ccall", "parse", "loading", "gmp",
         "sorting", "spawn", "backtrace", "exceptions",
         "file", "read", "version", "namedtuple",
-        "mpfr", "broadcast", "complex",
+        "mpfr", "broadcast", "complex", "no_invalidations",
         "floatapprox", "stdlib", "reflection", "regex", "float16",
         "combinatorics", "sysinfo", "env", "rounding", "ranges", "mod2pi",
         "euler", "show", "client", "terminfo",

test/no_invalidations.jl

@@ -0,0 +1,86 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Test
+
+module ThereAreNoInvalidations
+    function julia_expr_cmd(expr::Expr)
+        `$(Base.julia_cmd()) -e $expr`
+    end
+    function readline_julia_expr_cmd(expr::Expr)
+        open(readline, julia_expr_cmd(expr))
+    end
+    function invalidations_expr(expr::Expr)
+        quote
+            try
+                let invs = ccall(:jl_debug_method_invalidation, Any, (Cint,), 1)
+                    @eval $expr
+                    invs
+                end
+            finally
+                ccall(:jl_debug_method_invalidation, Any, (Cint,), 0)
+            end
+        end
+    end
+    function there_are_no_invalidations_expr(expr::Expr)
+        e = invalidations_expr(expr)
+        quote
+            let invalidations = $e
+                show(isempty(invalidations))
+            end
+        end
+    end
+    function there_are_no_invalidations(expr::Expr)
+        e = there_are_no_invalidations_expr(expr)
+        s = readline_julia_expr_cmd(e)
+        parse(Bool, s)
+    end
+end
+
+function type_expr(f, supertype::Type)
+    type_name = :T
+    rest = f(type_name)
+    quote
+        struct $type_name <: $supertype end
+        $rest
+    end
+end
+
+function test_expr(f, supertype::Type = Integer)
+    e = type_expr(f, supertype)
+    ThereAreNoInvalidations.there_are_no_invalidations(e)
+end
+
+@testset "no invalidations test set" begin
+    int_types = (Bool, Int8, UInt8, Int16, UInt16, Int, UInt, BigInt)
+    @testset "construction of old int types from new type" begin
+        broken = (Int8, UInt8, UInt16, Int, UInt)
+        @testset "T: $T" for T ∈ int_types
+            @test test_expr(n -> :(Base.$T(::$n) = $T(0))) broken=(T ∈ broken)
+        end
+    end
+    @testset "arithmetic between old int types and new int type" begin
+        ops = (:+, :*)
+        broken = ()
+        @testset "T: $T" for T ∈ int_types
+            @testset "op: $op" for op ∈ ops
+                @test (
+                    test_expr(n -> :(Base.$op(::$n, m::$T) = m)) &&
+                    test_expr(n -> :(Base.$op(m::$T, ::$n) = m))
+                ) broken=((T, op) ∈ broken)
+            end
+        end
+    end
+    @testset "promotion between old int types and new int type" begin
+        broken = (Bool, UInt8, Int)
+        @testset "T: $T" for T ∈ int_types
+            @test (
+                test_expr(n -> :(Base.promote_rule(::Type{$T}, ::Type{$n}) = $T)) &&
+                test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{$T}) = $T))
+            ) broken=(T ∈ broken)
+        end
+    end
+    @testset "unary functions" begin
+        @test test_expr(n -> :(Base.zero(::$n) = $n())) broken=true
+        @test test_expr(n -> :(Base.one(::$n) = $n())) broken=true
+    end
+end