feat(Core): introduce a QualifiedType cache

While it seems like this wouldn't be needed, on a large data collection
this change produced a ~60% decrease in parsing/construction (11s → 4s).

Core/src/model/globals.jl

@@ -69,6 +69,17 @@ const DATASET_REFERENCE_REGEX =
                  "(.+)", DATASET_REFERENCE_WRAPPER[2],
                  "\$"))
 
+"""
+    QUALIFIED_TYPE_CACHE
+
+A cache of [`QualifiedType`](@ref) instances, indexed by the type they represent.
+
+While one would hope that `QualifiedType(::Type)` calls would be constant-folded,
+in practice this is not the case, and so this cache is used to avoid an unfortunate
+large performance hit when constructing many `QualifiedType` instances.
+"""
+const QUALIFIED_TYPE_CACHE = Dict{Type, QualifiedType}()
+
 # For plugins / general information
 
 """

Core/src/model/qualifiedtype.jl

@@ -5,6 +5,9 @@ QualifiedType(m::Symbol, parents::Vector{Symbol}, name::Symbol) =
     QualifiedType(m, parents, name, ())
 
 function QualifiedType(::Type{T0}) where {T0}
+    let qt = get(QUALIFIED_TYPE_CACHE, T0, nothing)
+        !isnothing(qt) && return qt
+    end
     T = Base.unwrap_unionall(T0)
     alias = Base.make_typealias(T)
     root, name, params = if isnothing(alias)
@@ -22,7 +25,8 @@ function QualifiedType(::Type{T0}) where {T0}
         push!(parents, nameof(root))
         root = parentmodule(root)
     end
-    QualifiedType(nameof(root), parents, name, Tuple(params))
+    QUALIFIED_TYPE_CACHE[T0] =
+        QualifiedType(nameof(root), parents, name, Tuple(params))
 end
 
 Base.:(==)(a::QualifiedType, b::QualifiedType) =