Synchronize with upstream and fix

ClearScript.NoV8.sln.DotSettings

@@ -104,7 +104,6 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Numerics/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=oleaut/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Parameterless/@EntryIndexedValue">True</s:Boolean>
-
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Plex/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=prog/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ptrs/@EntryIndexedValue">True</s:Boolean>

ClearScript.sln.DotSettings

@@ -104,7 +104,6 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Numerics/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=oleaut/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Parameterless/@EntryIndexedValue">True</s:Boolean>
-
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Plex/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=prog/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ptrs/@EntryIndexedValue">True</s:Boolean>

ClearScript/ByRefArg.cs

@@ -46,34 +46,34 @@ public T Value
 
         public override object DynamicInvokeTarget => target.DynamicInvokeTarget;
 
-        public override HostTargetFlags GetFlags(IHostInvokeContext context)
+        public override HostTargetFlags GetFlags(IHostContext context)
         {
             return target.GetFlags(context);
         }
 
-        public override string[] GetAuxMethodNames(IHostInvokeContext context, BindingFlags bindFlags)
+        public override string[] GetAuxMethodNames(IHostContext context, BindingFlags bindFlags)
         {
             return target.GetAuxMethodNames(context, bindFlags);
         }
 
-        public override string[] GetAuxPropertyNames(IHostInvokeContext context, BindingFlags bindFlags)
+        public override string[] GetAuxPropertyNames(IHostContext context, BindingFlags bindFlags)
         {
             return target.GetAuxPropertyNames(context, bindFlags);
         }
 
-        public override bool TryInvokeAuxMember(IHostInvokeContext context, string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
+        public override bool TryInvokeAuxMember(IHostContext context, string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
         {
             return target.TryInvokeAuxMember(context, name, invokeFlags, args, bindArgs, out result);
         }
 
-        public override bool TryInvoke(IHostInvokeContext context, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
+        public override bool TryInvoke(IHostContext context, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
         {
             return target.TryInvoke(context, invokeFlags, args, bindArgs, out result);
         }
 
-        public override Invocability GetInvocability(BindingFlags bindFlags, Type accessContext, ScriptAccess defaultAccess, bool ignoreDynamic)
+        public override Invocability GetInvocability(IHostContext context, BindingFlags bindFlags, bool ignoreDynamic)
         {
-            return target.GetInvocability(bindFlags, accessContext, defaultAccess, ignoreDynamic);
+            return target.GetInvocability(context, bindFlags, ignoreDynamic);
         }
 
         #endregion

ClearScript/CanonicalRefTable.cs

@@ -40,9 +40,9 @@ private static ICanonicalRefMap GetMap(object obj)
                         type == typeof(TimeSpan) ||
                         type == typeof(Guid) ||
                     #if NET471_OR_GREATER || NETCOREAPP2_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-                        type.GetOrLoadCustomAttributes<System.Runtime.CompilerServices.IsReadOnlyAttribute>(false).Any() ||
+                        type.GetOrLoadCustomAttributes<System.Runtime.CompilerServices.IsReadOnlyAttribute>(null, false).Any() ||
                     #endif
-                        type.GetOrLoadCustomAttributes<ImmutableValueAttribute>(false).Any())
+                        type.GetOrLoadCustomAttributes<ImmutableValueAttribute>(null, false).Any())
                     {
                         map = (ICanonicalRefMap)typeof(CanonicalRefMap<>).MakeGenericType(type).CreateInstance();
                     }

ClearScript/CustomAttributeCache.cs

@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.ClearScript.Util;
+
+namespace Microsoft.ClearScript
+{
+    internal sealed class CustomAttributeCache
+    {
+        private readonly ConditionalWeakTable<ICustomAttributeProvider, Entry> table = new ConditionalWeakTable<ICustomAttributeProvider, Entry>();
+
+        public T[] GetOrLoad<T>(CustomAttributeLoader loader, ICustomAttributeProvider resource, bool inherit) where T : Attribute
+        {
+            lock (table)
+            {
+                return GetOrLoad<T>(loader, table.GetOrCreateValue(resource), resource, inherit);
+            }
+        }
+
+        private T[] GetOrLoad<T>(CustomAttributeLoader loader, Entry entry, ICustomAttributeProvider resource, bool inherit) where T : Attribute
+        {
+            if (entry.TryGet<T>(out var attrs))
+            {
+                return attrs;
+            }
+
+            attrs = Load<T>(GetIsBypass(entry, resource) ? CustomAttributeLoader.Default : loader, resource, inherit);
+            entry.Add(attrs);
+
+            return attrs;
+        }
+
+        private static T[] Load<T>(CustomAttributeLoader loader, ICustomAttributeProvider resource, bool inherit) where T : Attribute
+        {
+            return loader.LoadCustomAttributes<T>(resource, inherit) ?? ArrayHelpers.GetEmptyArray<T>();
+        }
+
+        private bool GetIsBypass(ICustomAttributeProvider resource)
+        {
+            // ReSharper disable once InconsistentlySynchronizedField
+            return GetIsBypass(table.GetOrCreateValue(resource), resource);
+        }
+
+        private bool GetIsBypass(Entry entry, ICustomAttributeProvider resource)
+        {
+            if (!entry.IsBypass.HasValue)
+            {
+                entry.IsBypass = GetIsBypassInternal(resource);
+            }
+
+            return entry.IsBypass.Value;
+        }
+
+        private bool GetIsBypassInternal(ICustomAttributeProvider resource)
+        {
+            if (Load<BypassCustomAttributeLoaderAttribute>(CustomAttributeLoader.Default, resource, false).Length > 0)
+            {
+                return true;
+            }
+
+            var parent = GetParent(resource);
+            if (parent != null)
+            {
+                return GetIsBypass(parent);
+            }
+
+            return false;
+        }
+
+        private static ICustomAttributeProvider GetParent(ICustomAttributeProvider resource)
+        {
+            if (resource is ParameterInfo parameter)
+            {
+                return parameter.Member;
+            }
+
+            if (resource is Type type)
+            {
+                return (type.DeclaringType as ICustomAttributeProvider) ?? type.Module;
+            }
+
+            if (resource is MemberInfo member)
+            {
+                return member.DeclaringType;
+            }
+
+            if (resource is Module module)
+            {
+                return module.Assembly;
+            }
+
+            return null;
+        }
+
+        #region Nested type: Entry
+
+        // ReSharper disable ClassNeverInstantiated.Local
+
+        private sealed class Entry
+        {
+            private readonly Dictionary<Type, object> map = new Dictionary<Type, object>();
+
+            public bool? IsBypass { get; set; }
+
+            public void Add<T>(T[] attrs)
+            {
+                map.Add(typeof(T), attrs);
+            }
+
+            public bool TryGet<T>(out T[] attrs)
+            {
+                if (map.TryGetValue(typeof(T), out var attrsObject))
+                {
+                    attrs = attrsObject as T[];
+                    return true;
+                }
+
+                attrs = null;
+                return false;
+            }
+        }
+
+        // ReSharper restore ClassNeverInstantiated.Local
+
+        #endregion
+    }
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false)]
+    internal sealed class BypassCustomAttributeLoaderAttribute : Attribute
+    {
+    }
+}

ClearScript/CustomAttributeLoader.cs

@@ -12,6 +12,8 @@ namespace Microsoft.ClearScript
     /// </summary>
     public class CustomAttributeLoader
     {
+        private readonly CustomAttributeCache cache = new CustomAttributeCache();
+
         // ReSharper disable EmptyConstructor
 
         /// <summary>
@@ -22,6 +24,11 @@ public CustomAttributeLoader()
             // the help file builder (SHFB) insists on an empty constructor here
         }
 
+        /// <summary>
+        /// Gets the default custom attribute loader.
+        /// </summary>
+        public static CustomAttributeLoader Default { get; } = new CustomAttributeLoader();
+
         // ReSharper restore EmptyConstructor
 
         /// <summary>
@@ -60,5 +67,10 @@ public virtual T[] LoadCustomAttributes<T>(ICustomAttributeProvider resource, bo
 
             return resource.GetCustomAttributes(typeof(T), inherit).OfType<T>().ToArray();
         }
+
+        internal T[] GetOrLoad<T>(ICustomAttributeProvider resource, bool inherit) where T : Attribute
+        {
+            return cache.GetOrLoad<T>(this, resource, inherit);
+        }
     }
 }