Add checks for Type.IsNestedPublic where appropriate. Make sure private types are not accessed via RT.classForName. Make some inner classes public that were previously accessed by RT.classForName even though they were private

dmiller · dmiller · commit a53a09047228 · 2025-03-13T17:17:49.000-04:00
diff --git a/Clojure/Clojure/CljCompiler/Ast/ConstantExpr.cs b/Clojure/Clojure/CljCompiler/Ast/ConstantExpr.cs
@@ -8,10 +8,6 @@
  *   You must not remove this notice, or any other, from this software.
  **/
 
-/**
- *   Author: David Miller
- **/
-
 using System;
 using System.Reflection.Emit;
 
@@ -45,7 +41,8 @@ public override bool HasClrType
         {
             get 
             { 
-                return _v.GetType().IsPublic 
+                return _v.GetType().IsPublic
+                    || _v.GetType().IsNestedPublic
                     || typeof(Type).IsInstanceOfType(_v);   // This bit of hackery is due to the fact that RuntimeType is not public.  
                                                             // Without this, System.Int64 would be seen as only type System.Object, not System.RuntimeType.
             }
diff --git a/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs b/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs
@@ -8,10 +8,6 @@
  *   You must not remove this notice, or any other, from this software.
  **/
 
-/**
- *   Author: David Miller
- **/
-
 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
@@ -168,7 +164,7 @@ public static void CacheDelegate(int key, Delegate d)
 
         private void EmitComplexCall(ObjExpr objx, CljILGen ilg)
         {
-            // TOD: We have gotten rid of light-compile. Simplify this.
+            // TODO: We have gotten rid of light-compile. Simplify this.
             // This is made more complex than I'd like by light-compiling.
             // Without light-compile, we could just:
             //   Emit the target expression
diff --git a/Clojure/Clojure/CljCompiler/Ast/ObjExpr.cs b/Clojure/Clojure/CljCompiler/Ast/ObjExpr.cs
@@ -64,38 +64,17 @@ public class ObjExpr : Expr
         public IPersistentVector KeywordCallsites { get; protected set; }
         public IPersistentVector ProtocolCallsites { get; protected set; }
         public IPersistentSet VarCallsites { get; protected set; }
-
-
-
         public IList<FieldBuilder> KeywordLookupSiteFields { get; protected set; }
-
         public IList<FieldBuilder> ThunkFields { get; protected set; }
-
         public IList<FieldBuilder> CachedTypeFields { get; protected set; }
 
-
-        internal FieldBuilder KeywordLookupSiteField(int i)
-        {
-            return KeywordLookupSiteFields[i];
-        }
-
-        internal FieldBuilder CachedTypeField(int i)
-        {
-            return CachedTypeFields[i];
-        }
-
-        internal FieldBuilder ThunkField(int i)
-        {
-            return ThunkFields[i];
-        }
-
+        internal FieldBuilder KeywordLookupSiteField(int i) => KeywordLookupSiteFields[i];
+        internal FieldBuilder CachedTypeField(int i) => CachedTypeFields[i];
+        internal FieldBuilder ThunkField(int i) => ThunkFields[i];
 
         public FieldBuilder MetaField { get; protected set; }
-
         public IList<FieldBuilder> ClosedOverFields { get; protected set; }
-
         public Dictionary<LocalBinding, FieldBuilder> ClosedOverFieldsMap { get; protected set; }
-
         public Dictionary<FieldBuilder, LocalBinding> ClosedOverFieldsToBindingsMap { get; protected set; }
         public IPersistentVector HintedFields { get; protected set; }
 
@@ -107,9 +86,8 @@ internal FieldBuilder ThunkField(int i)
         public bool OnceOnly { get; protected set; }
         public bool CanBeDirect { get; protected set; }
 
-        
-        protected bool IsDefType { get { return Fields != null; } }
-        protected virtual bool SupportsMeta { get { return !IsDefType; } }
+        protected bool IsDefType => Fields is not null;
+        protected virtual bool SupportsMeta => !IsDefType;
 
         internal bool IsVolatile(LocalBinding lb)
         {
@@ -127,41 +105,18 @@ internal bool IsMutable(LocalBinding lb)
                 lb.IsByRef;
         }
 
-        static String SiteName(int n)
-        {
-            return "__site__" + n;
-        }
-
-        public static String SiteNameStatic(int n)
-        {
-            return SiteName(n) + "__";
-        }
-
-        static String ThunkName(int n)
-        {
-            return "__thunk__" + n;
-        }
-
-        public static String ThunkNameStatic(int n)
-        {
-            return ThunkName(n) + "__";
-        }
-
-        internal static String CachedClassName(int n)
-        {
-            return "__cached_class__" + n;
-        }
-
-        private static string ConstantName(int i)
-        {
-            return ConstPrefix + i;
-        }
+        static String SiteName(int n) => "__site__" + n;
+        public static String SiteNameStatic(int n) => SiteName(n) + "__";
+        static String ThunkName(int n) => "__thunk__" + n;
+        public static String ThunkNameStatic(int n) => ThunkName(n) + "__";
+        internal static String CachedClassName(int n) => "__cached_class__" + n;
+        private static string ConstantName(int i) => ConstPrefix + i;
 
         private Type ConstantType(int i)
         {
             object o = Constants.nth(i);
             Type t = o?.GetType();
-            if (t != null && t.IsPublic)
+            if (t != null && (t.IsPublic || t.IsNestedPublic))
             {
                 // Java: can't emit derived fn types due to visibility
                 if (typeof(LazySeq).IsAssignableFrom(t))
diff --git a/Clojure/Clojure/Lib/PersistentArrayMap.cs b/Clojure/Clojure/Lib/PersistentArrayMap.cs
@@ -516,7 +516,7 @@ public override IPersistentMap without(object key)
         /// for <see cref="PersistentArrayMap">PersistentArrayMap</see>s.
         /// </summary>
         [Serializable]
-        protected class Seq : ASeq, Counted, IReduce, IDrop, IEnumerable
+        public class Seq : ASeq, Counted, IReduce, IDrop, IEnumerable
         {
             #region Data
 
diff --git a/Clojure/Clojure/Lib/PersistentHashMap.cs b/Clojure/Clojure/Lib/PersistentHashMap.cs
@@ -1842,7 +1842,7 @@ public static IEnumerator<T> GetEnumeratorT<T>(object[] array, KVMangleDel<T> d)
         #region NodeSeq
 
         [Serializable]
-        sealed class NodeSeq : ASeq
+        public sealed class NodeSeq : ASeq
         {
 
             #region Data
diff --git a/Clojure/Clojure/Lib/RT.cs b/Clojure/Clojure/Lib/RT.cs
@@ -65,7 +65,7 @@ static IEnumerable<Type> GetAllTypesInNamespace(string nspace)
                        .SelectMany(t => getTypes(t))
                        .Where(t => (t.IsClass || t.IsInterface || t.IsValueType) &&
                                     t.Namespace == nspace &&
-                                    t.IsPublic &&
+                                    (t.IsPublic || t.IsNestedPublic) &&
                                     !t.IsGenericTypeDefinition &&
                                     !t.Name.StartsWith("_") &&
                                     !t.Name.StartsWith("<"));
@@ -2767,7 +2767,7 @@ public static Type classForName(string p)
             // e.g. System.Environment in assemblies System.Private.CoreLib and System.Runtime.Exceptions.
             // It is private in the former and public in the latter.
             // Unfortunately, Type.GetType was finding the former.
-            if (t != null && t.IsPublic)
+            if (t != null && (t.IsPublic || t.IsNestedPublic))
                 return t;
 
             t = Compiler.FindDuplicateType(p);
@@ -2783,38 +2783,36 @@ public static Type classForName(string p)
             foreach (Assembly assy in assys)
             {
                 Type t1 = assy.GetType(p, false);
-                if (t1 != null && t1.IsPublic)
+                if (t1 != null && (t1.IsPublic || t1.IsNestedPublic))
                     return t1;
             }
 
             // slow path, will succeed for display names (returned by Type.Name)
             // e.g. "Transform"
             foreach (Assembly assy1 in assys)
             {
-                Type t1 = assy1.GetType(p, false);
+                Type t1 = null;
 
                 if (IsRunningOnMono)
                 {
                     // I do not know why Assembly.GetType fails to find types in our assemblies in Mono
-                    if (t1 == null)
+
+                    if (!assy1.IsDynamic)
                     {
-                        if (!assy1.IsDynamic)
+                        try
                         {
-                            try
-                            {
 
-                                foreach (Type tt in assy1.GetTypes())
+                            foreach (Type tt in assy1.GetTypes())
+                            {
+                                if (tt.Name.Equals(p))
                                 {
-                                    if (tt.Name.Equals(p))
-                                    {
-                                        t1 = tt;
-                                        break;
-                                    }
+                                    t1 = tt;
+                                    break;
                                 }
                             }
-                            catch (System.Reflection.ReflectionTypeLoadException)
-                            {
-                            }
+                        }
+                        catch (System.Reflection.ReflectionTypeLoadException)
+                        {
                         }
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,6 @@`
`8`	`8`	`* You must not remove this notice, or any other, from this software.`
`9`	`9`	`**/`
`10`	`10`
`11`		`-/**`
`12`		`- * Author: David Miller`
`13`		`- **/`
`14`		`-`
`15`	`11`	`using System;`
`16`	`12`	`using System.Reflection.Emit;`
`17`	`13`
`@@ -45,7 +41,8 @@ public override bool HasClrType`
`45`	`41`	`{`
`46`	`42`	`get`
`47`	`43`	`{`
`48`		`- return _v.GetType().IsPublic`
	`44`	`+ return _v.GetType().IsPublic`
	`45`	`+ \|\| _v.GetType().IsNestedPublic`
`49`	`46`	`\|\| typeof(Type).IsInstanceOfType(_v); // This bit of hackery is due to the fact that RuntimeType is not public.`
`50`	`47`	`// Without this, System.Int64 would be seen as only type System.Object, not System.RuntimeType.`
`51`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -516,7 +516,7 @@ public override IPersistentMap without(object key)`
`516`	`516`	`/// for <see cref="PersistentArrayMap">PersistentArrayMap</see>s.`
`517`	`517`	`/// </summary>`
`518`	`518`	`[Serializable]`
`519`		`- protected class Seq : ASeq, Counted, IReduce, IDrop, IEnumerable`
	`519`	`+ public class Seq : ASeq, Counted, IReduce, IDrop, IEnumerable`
`520`	`520`	`{`
`521`	`521`	`#region Data`
`522`	`522`
Original file line number	Diff line number	Diff line change
`@@ -1842,7 +1842,7 @@ public static IEnumerator<T> GetEnumeratorT<T>(object[] array, KVMangleDel<T> d)`
`1842`	`1842`	`#region NodeSeq`
`1843`	`1843`
`1844`	`1844`	`[Serializable]`
`1845`		`- sealed class NodeSeq : ASeq`
	`1845`	`+ public sealed class NodeSeq : ASeq`
`1846`	`1846`	`{`
`1847`	`1847`
`1848`	`1848`	`#region Data`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ static IEnumerable<Type> GetAllTypesInNamespace(string nspace)`
`65`	`65`	`.SelectMany(t => getTypes(t))`
`66`	`66`	`.Where(t => (t.IsClass \|\| t.IsInterface \|\| t.IsValueType) &&`
`67`	`67`	`t.Namespace == nspace &&`
`68`		`- t.IsPublic &&`
	`68`	`+ (t.IsPublic \|\| t.IsNestedPublic) &&`
`69`	`69`	`!t.IsGenericTypeDefinition &&`
`70`	`70`	`!t.Name.StartsWith("_") &&`
`71`	`71`	`!t.Name.StartsWith("<"));`
`@@ -2767,7 +2767,7 @@ public static Type classForName(string p)`
`2767`	`2767`	`// e.g. System.Environment in assemblies System.Private.CoreLib and System.Runtime.Exceptions.`
`2768`	`2768`	`// It is private in the former and public in the latter.`
`2769`	`2769`	`// Unfortunately, Type.GetType was finding the former.`
`2770`		`- if (t != null && t.IsPublic)`
	`2770`	`+ if (t != null && (t.IsPublic \|\| t.IsNestedPublic))`
`2771`	`2771`	`return t;`
`2772`	`2772`
`2773`	`2773`	`t = Compiler.FindDuplicateType(p);`
`@@ -2783,38 +2783,36 @@ public static Type classForName(string p)`
`2783`	`2783`	`foreach (Assembly assy in assys)`
`2784`	`2784`	`{`
`2785`	`2785`	`Type t1 = assy.GetType(p, false);`
`2786`		`- if (t1 != null && t1.IsPublic)`
	`2786`	`+ if (t1 != null && (t1.IsPublic \|\| t1.IsNestedPublic))`
`2787`	`2787`	`return t1;`
`2788`	`2788`	`}`
`2789`	`2789`
`2790`	`2790`	`// slow path, will succeed for display names (returned by Type.Name)`
`2791`	`2791`	`// e.g. "Transform"`
`2792`	`2792`	`foreach (Assembly assy1 in assys)`
`2793`	`2793`	`{`
`2794`		`- Type t1 = assy1.GetType(p, false);`
	`2794`	`+ Type t1 = null;`
`2795`	`2795`
`2796`	`2796`	`if (IsRunningOnMono)`
`2797`	`2797`	`{`
`2798`	`2798`	`// I do not know why Assembly.GetType fails to find types in our assemblies in Mono`
`2799`		`- if (t1 == null)`
	`2799`	`+`
	`2800`	`+ if (!assy1.IsDynamic)`
`2800`	`2801`	`{`
`2801`		`- if (!assy1.IsDynamic)`
	`2802`	`+ try`
`2802`	`2803`	`{`
`2803`		`- try`
`2804`		`- {`
`2805`	`2804`
`2806`		`- foreach (Type tt in assy1.GetTypes())`
	`2805`	`+ foreach (Type tt in assy1.GetTypes())`
	`2806`	`+ {`
	`2807`	`+ if (tt.Name.Equals(p))`
`2807`	`2808`	`{`
`2808`		`- if (tt.Name.Equals(p))`
`2809`		`- {`
`2810`		`- t1 = tt;`
`2811`		`- break;`
`2812`		`- }`
	`2809`	`+ t1 = tt;`
	`2810`	`+ break;`
`2813`	`2811`	`}`
`2814`	`2812`	`}`
`2815`		`- catch (System.Reflection.ReflectionTypeLoadException)`
`2816`		`- {`
`2817`		`- }`
	`2813`	`+ }`
	`2814`	`+ catch (System.Reflection.ReflectionTypeLoadException)`
	`2815`	`+ {`
`2818`	`2816`	`}`
`2819`	`2817`	`}`
`2820`	`2818`	`}`