ClearScript 5.1: ScriptEngine.AddRestrictedHostObject(), ScriptMemberAttribute, NoScriptAccessAttribute, improved method bind plumbing and V8 GlobalMembers support, lots of new tests.

Author: ClearScriptLib

ClearScript/ByRefArg.cs

@@ -132,14 +132,14 @@ public override string[] GetAuxPropertyNames(BindingFlags bindFlags)
             return target.GetAuxPropertyNames(bindFlags);
         }
 
-        public override bool TryInvokeAuxMember(string name, BindingFlags invokeFlags, object[] args, out object result)
+        public override bool TryInvokeAuxMember(string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
         {
-            return target.TryInvokeAuxMember(name, invokeFlags, args, out result);
+            return target.TryInvokeAuxMember(name, invokeFlags, args, bindArgs, out result);
         }
 
-        public override bool TryInvoke(BindingFlags invokeFlags, object[] args, out object result)
+        public override bool TryInvoke(BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
         {
-            return target.TryInvoke(invokeFlags, args, out result);
+            return target.TryInvoke(invokeFlags, args, bindArgs, out result);
         }
 
         #endregion

ClearScript/ClearScript.csproj

@@ -60,13 +60,18 @@
     <Compile Include="HostTargetFlags.cs" />
     <Compile Include="IScriptableObject.cs" />
     <Compile Include="BindSignature.cs" />
+    <Compile Include="NoScriptAccessAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
       <DependentUpon>AssemblyInfo.tt</DependentUpon>
     </Compile>
+    <Compile Include="ScriptAccess.cs" />
     <Compile Include="ScriptMethod.cs" />
+    <Compile Include="ScriptMemberAttribute.cs" />
+    <Compile Include="ScriptUsageAttribute.cs" />
     <Compile Include="Util\IScriptMarshalWrapper.cs" />
+    <Compile Include="Util\MemberHelpers.cs" />
     <Compile Include="Windows\WindowsScriptEngineFlags.cs" />
     <Compile Include="Util\IDynamic.cs" />
     <Compile Include="Util\SpecialMemberNames.cs" />

ClearScript/ContinuationCallback.cs

@@ -62,7 +62,7 @@
 namespace Microsoft.ClearScript
 {
     /// <summary>
-    /// Represents the method that indicates to a script engine whether script execution should continue.
+    /// Represents the method that specifies to a script engine whether script execution should continue.
     /// </summary>
     /// <returns><c>True</c> to continue script execution, <c>false</c> to interrupt it.</returns>
     /// <seealso cref="ScriptEngine.ContinuationCallback"/>

ClearScript/ExtensionMethods.cs

@@ -85,17 +85,17 @@ public bool ProcessType(Type type)
             if (!table.ContainsKey(type) && type.HasExtensionMethods())
             {
                 const BindingFlags bindFlags = BindingFlags.Public | BindingFlags.Static;
-                table[type] = type.GetMethods(bindFlags).Where(IsExtensionMethod).ToArray();
+                table[type] = type.GetMethods(bindFlags).Where(IsScriptableExtensionMethod).ToArray();
                 summary = new ExtensionMethodSummary(table);
                 return true;
             }
 
             return false;
         }
 
-        private static bool IsExtensionMethod(MethodInfo method)
+        private static bool IsScriptableExtensionMethod(MethodInfo method)
         {
-            return !method.IsSpecialName && method.IsDefined(typeof(ExtensionAttribute), false);
+            return method.IsScriptable() && method.IsDefined(typeof(ExtensionAttribute), false);
         }
     }
 
@@ -112,7 +112,7 @@ public ExtensionMethodSummary(Dictionary<Type, MethodInfo[]> table)
         {
             Types = table.Keys.ToArray();
             Methods = table.SelectMany(pair => pair.Value).ToArray();
-            MethodNames = Methods.Select(method => method.Name).ToArray();
+            MethodNames = Methods.Select(method => method.GetScriptName()).ToArray();
         }
 
         public Type[] Types { get; private set; }

ClearScript/HostEvent.cs

@@ -89,6 +89,16 @@ internal EventSource(ScriptEngine engine, object source, EventInfo eventInfo)
             this.eventInfo = eventInfo;
         }
 
+        internal object Source
+        {
+            get { return source; }
+        }
+
+        internal EventInfo EventInfo
+        {
+            get { return eventInfo; }
+        }
+
         #region script-callable interface
 
         // ReSharper disable InconsistentNaming

ClearScript/HostFunctions.cs

@@ -86,6 +86,7 @@ public class HostFunctions : IScriptableObject
         /// </summary>
         public HostFunctions()
         {
+            // the help file builder (SHFB) insists on an empty constructor here
         }
 
         // ReSharper restore EmptyConstructor
@@ -656,6 +657,7 @@ public class ExtendedHostFunctions : HostFunctions
         /// </summary>
         public ExtendedHostFunctions()
         {
+            // the help file builder (SHFB) insists on an empty constructor here
         }
 
         // ReSharper restore EmptyConstructor

ClearScript/HostIndexer.cs

@@ -119,19 +119,19 @@ public override string[] GetAuxMethodNames(BindingFlags bindFlags)
             return auxMethodNames;
         }
 
-        public override bool TryInvokeAuxMember(string memberName, BindingFlags invokeFlags, object[] args, out object result)
+        public override bool TryInvokeAuxMember(string memberName, BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
         {
             if (invokeFlags.HasFlag(BindingFlags.InvokeMethod))
             {
                 if (memberName == "get")
                 {
-                    result = target.InvokeMember(name, BindingFlags.GetProperty, args, null);
+                    result = target.InvokeMember(name, BindingFlags.GetProperty, args, bindArgs, null);
                     return true;
                 }
 
                 if (memberName == "set")
                 {
-                    result = target.InvokeMember(name, BindingFlags.SetProperty, args, null);
+                    result = target.InvokeMember(name, BindingFlags.SetProperty, args, bindArgs, null);
                     return true;
                 }
             }
@@ -140,9 +140,9 @@ public override bool TryInvokeAuxMember(string memberName, BindingFlags invokeFl
             return false;
         }
 
-        public override bool TryInvoke(BindingFlags invokeFlags, object[] args, out object result)
+        public override bool TryInvoke(BindingFlags invokeFlags, object[] args, object[] bindArgs, out object result)
         {
-            result = target.InvokeMember(name, invokeFlags.HasFlag(BindingFlags.SetField) ? BindingFlags.SetProperty : BindingFlags.GetProperty, args, null);
+            result = target.InvokeMember(name, invokeFlags.HasFlag(BindingFlags.SetField) ? BindingFlags.SetProperty : BindingFlags.GetProperty, args, bindArgs, null);
             return true;
         }
 

ClearScript/HostItem.Invoke.cs

@@ -76,28 +76,33 @@ internal partial class HostItem
     {
         #region internal members
 
-        private object InvokeMethod(string name, object[] args)
+        private object InvokeMethod(string name, object[] args, object[] bindArgs)
         {
             var typeArgs = GetTypeArgs(args).ToArray();
             if (typeArgs.Length > 0)
             {
                 args = args.Skip(typeArgs.Length).ToArray();
+                bindArgs = bindArgs.Skip(typeArgs.Length).ToArray();
             }
 
-            return InvokeMethod(name, typeArgs, args);
+            return InvokeMethod(name, typeArgs, args, bindArgs);
         }
 
-        private object InvokeMethod(string name, Type[] typeArgs, object[] args)
+        private object InvokeMethod(string name, Type[] typeArgs, object[] args, object[] bindArgs)
         {
-            var bindResult = BindMethod(name, typeArgs, args);
+            var bindResult = BindMethod(name, typeArgs, args, bindArgs);
             if ((bindResult is MethodBindFailure) && target.Flags.HasFlag(HostTargetFlags.AllowExtensionMethods))
             {
-                var targetArg = new[] { target.DynamicInvokeTarget };
+                var targetArg = new[] { target.Target };
                 var extensionArgs = targetArg.Concat(args).ToArray();
+
+                var targetBindArg = new object[] { target };
+                var extensionBindArgs = targetBindArg.Concat(bindArgs).ToArray();
+
                 foreach (var type in cachedExtensionMethodSummary.Types)
                 {
                     var extensionHostItem = (HostItem)Wrap(engine, HostType.Wrap(type));
-                    var extensionBindResult = extensionHostItem.BindMethod(name, typeArgs, extensionArgs);
+                    var extensionBindResult = extensionHostItem.BindMethod(name, typeArgs, extensionArgs, extensionBindArgs);
                     if (extensionBindResult is MethodBindSuccess)
                     {
                         return extensionBindResult.Invoke(engine);
@@ -128,67 +133,73 @@ private static IEnumerable<Type> GetTypeArgs(object[] args)
             }
         }
 
-        private MethodBindResult BindMethod(string name, Type[] typeArgs, object[] args)
+        private MethodBindResult BindMethod(string name, Type[] typeArgs, object[] args, object[] bindArgs)
         {
-            MethodBindResult result = null;
-
             // WARNING: BindSignature holds on to the specified typeArgs; subsequent modification
             // will result in bugs that are difficult to diagnose. Create a copy if necessary.
 
+            var signature = new BindSignature(target, name, typeArgs, bindArgs);
+            MethodBindResult result;
+
             object rawResult;
-            var signature = new BindSignature(target, name, typeArgs, args);
             if (engine.TryGetCachedBindResult(signature, out rawResult))
             {
                 result = MethodBindResult.Create(name, rawResult, target, args);
             }
             else
             {
-                var entryList = new List<MethodBindEntry>();
-                if ((target is HostType) || (target.InvokeTarget == null) || !target.Type.IsInterface)
+                result = BindMethodInternal(name, typeArgs, args, bindArgs);
+                if (!result.IsPreferredMethod(name))
                 {
-                    entryList.Add(new MethodBindEntry(name, accessContext ?? engine.AccessContext));
-                }
-                else
-                {
-                    foreach (var mapping in target.InvokeTarget.GetType().ExtGetInterfaceMaps(target.Type))
-                    {
-                        for (var index = 0; index < mapping.InterfaceMethods.Length; index++)
-                        {
-                            if (mapping.InterfaceMethods[index].Name == name)
-                            {
-                                var targetMethod = mapping.TargetMethods[index];
-                                entryList.Add(new MethodBindEntry(targetMethod.Name, targetMethod.DeclaringType));
-                            }
-                        }
-                    }
-
-                    if (entryList.Count < 1)
+                    if (result is MethodBindSuccess)
                     {
-                        entryList.Add(new MethodBindEntry(name, accessContext ?? engine.AccessContext));
+                        result = new MethodBindFailure(new MissingMemberException(MiscHelpers.FormatInvariant("Object has no method named '{0}' that matches the specified arguments", name)));
                     }
-                }
-
-                foreach (var entry in entryList)
-                {
-                    const CSharpBinderFlags binderFlags = CSharpBinderFlags.InvokeSimpleName | CSharpBinderFlags.ResultDiscarded;
-                    var binder = Binder.InvokeMember(binderFlags, entry.Name, typeArgs, entry.AccessContext, CreateArgInfoEnum(args));
 
-                    var binding = DynamicHelpers.Bind((DynamicMetaObjectBinder)binder, target.DynamicInvokeTarget, args);
-                    rawResult = (new MethodBindingVisitor(target.InvokeTarget, entry.Name, binding.Expression)).Result;
-                    result = MethodBindResult.Create(entry.Name, rawResult, target, args);
-                    if (result is MethodBindSuccess)
+                    foreach (var altName in GetAltMethodNames(name))
                     {
-                        break;
+                        var altResult = BindMethodInternal(altName, typeArgs, args, bindArgs);
+                        if (altResult.IsUnblockedMethod())
+                        {
+                            result = altResult;
+                            break;
+                        }
                     }
                 }
 
-                Debug.Assert(rawResult != null);
-                engine.CacheBindResult(signature, rawResult);
+                engine.CacheBindResult(signature, result.RawResult);
             }
 
             return result;
         }
 
+        private MethodBindResult BindMethodInternal(string name, Type[] typeArgs, object[] args, object[] bindArgs)
+        {
+            const CSharpBinderFlags binderFlags = CSharpBinderFlags.InvokeSimpleName | CSharpBinderFlags.ResultDiscarded;
+            var binder = Binder.InvokeMember(binderFlags, name, typeArgs, accessContext ?? engine.AccessContext, CreateArgInfoEnum(bindArgs));
+
+            var binding = DynamicHelpers.Bind((DynamicMetaObjectBinder)binder, target, bindArgs);
+            var rawResult = (new MethodBindingVisitor(target.InvokeTarget, name, binding.Expression)).Result;
+            return MethodBindResult.Create(name, rawResult, target, args);
+        }
+
+        private IEnumerable<string> GetAltMethodNames(string name)
+        {
+            return GetAltMethodNamesInternal(name).Distinct();
+        }
+
+        private IEnumerable<string> GetAltMethodNamesInternal(string name)
+        {
+            foreach (var method in target.Type.GetScriptableMethods(name, GetMethodBindFlags()))
+            {
+                var methodName = method.GetShortName();
+                if (methodName != name)
+                {
+                    yield return methodName;
+                }
+            }
+        }
+
         private IEnumerable<CSharpArgumentInfo> CreateArgInfoEnum(object[] args)
         {
             if (target is HostType)
@@ -208,14 +219,14 @@ private IEnumerable<CSharpArgumentInfo> CreateArgInfoEnum(object[] args)
 
         private static CSharpArgumentInfo CreateArgInfo(object arg)
         {
-            var flags = CSharpArgumentInfoFlags.None;
+            var flags = CSharpArgumentInfoFlags.UseCompileTimeType;
             if (arg is IOutArg)
             {
-                flags |= CSharpArgumentInfoFlags.IsOut | CSharpArgumentInfoFlags.UseCompileTimeType;
+                flags |= CSharpArgumentInfoFlags.IsOut;
             }
             else if (arg is IRefArg)
             {
-                flags |= CSharpArgumentInfoFlags.IsRef | CSharpArgumentInfoFlags.UseCompileTimeType;
+                flags |= CSharpArgumentInfoFlags.IsRef;
             }
 
             return CSharpArgumentInfo.Create(flags, null);
@@ -228,23 +239,6 @@ private static CSharpArgumentInfo CreateStaticTypeArgInfo()
 
         #endregion
 
-        #region Nested type: MethodBindEntry
-
-        private struct MethodBindEntry
-        {
-            public readonly string Name;
-
-            public readonly Type AccessContext;
-
-            public MethodBindEntry(string name, Type accessContext)
-            {
-                Name = name;
-                AccessContext = accessContext;
-            }
-        }
-
-        #endregion
-
         #region Nested type: MethodBindResult
 
         private abstract class MethodBindResult
@@ -265,6 +259,12 @@ public static MethodBindResult Create(string name, object rawResult, HostTarget
                 return new MethodBindFailure((rawResult as Exception) ?? new NotSupportedException(MiscHelpers.FormatInvariant("Invocation of method '{0}' failed (unrecognized binding)", name)));
             }
 
+            public abstract object RawResult { get; }
+
+            public abstract bool IsPreferredMethod(string name);
+
+            public abstract bool IsUnblockedMethod();
+
             public abstract object Invoke(ScriptEngine engine);
         }
 
@@ -289,6 +289,21 @@ public MethodBindSuccess(HostTarget hostTarget, MethodInfo method, object[] args
 
             #region MethodBindResult overrides
 
+            public override object RawResult
+            {
+                get { return method; }
+            }
+
+            public override bool IsPreferredMethod(string name)
+            {
+                return !method.IsBlockedFromScript() && (method.GetScriptName() == name);
+            }
+
+            public override bool IsUnblockedMethod()
+            {
+                return !method.IsBlockedFromScript();
+            }
+
             public override object Invoke(ScriptEngine engine)
             {
                 if (method == getTypeMethod)
@@ -317,6 +332,20 @@ public MethodBindFailure(Exception exception)
 
             #region MethodBindResult overrides
 
+            public override object RawResult
+            {
+                get { return exception; }
+            }
+
+            public override bool IsPreferredMethod(string name)
+            {
+                return false;
+            }
+
+            public override bool IsUnblockedMethod()
+            {
+                return false;
+            }
             public override object Invoke(ScriptEngine engine)
             {
                 throw exception;