C# IMethodSymbol.GetMemberName方法代码示例

        public JsExpression CreateObject(JsExpression containingType, IMethodSymbol constructor, params JsExpression[] arguments)
        {
            var constructorReference = containingType.Member("prototype").Member(constructor.GetMemberName());

            if (constructor.IsBuiltIn())
            {
                // If the constructor is built-in, then we don't want it invoked at all, since it's just a shim for the built-in
                // version.  Therefore, just call the types constructor passing in the arguments as usual for a normal JS new.
                return Js.New(containingType, arguments);
            }
            else
            {
                // Object creation gets transformed into:
                // new T(T.prototype.ctor, arg1, arg2, arg3...)
                return constructorReference.Member(SpecialNames.New).Invoke(arguments);
            }
        }

        public JsInvocationExpression InvokeStatic(IMethodSymbol method, params JsExpression[] args)
        {
            args = method.TypeArguments.Select(x => TypeAndResolve(x)).Concat(args).ToArray();

            JsExpression target;
            if (Equals(method.ContainingType, Context.Instance.SpecialFunctions))
                target = Js.Reference(method.GetMemberName());
            else
                target = Type(method.ContainingType).Member(method.GetMemberName());

            return target.Invoke(args);
        }

 public JsExpression GetMethodFunction(IMethodSymbol method, bool forceUnconstructedScope = false)
 {
     // Handle type arguments in the containing type
     JsExpression typeReference = Type(method.ContainingType, forceUnconstructedScope);
     var target = method.IsStatic ? typeReference : typeReference.Member("prototype");
     return target.Member(method.GetMemberName());            
 }

 public JsInvocationExpression Invoke(JsExpression target, IMethodSymbol method, params JsExpression[] arguments)
 {
     return target.Member(method.GetMemberName()).Invoke(arguments);
 }

 public JsInvocationExpression InvokeMethodAs(IMethodSymbol method, JsExpression @this, params JsExpression[] arguments)
 {
     var containingMember = Type(method.ContainingType);
     if (!method.IsStatic)
         containingMember = containingMember.Member("prototype");
     return containingMember.Member(method.GetMemberName()).Member("call")
         .Invoke(new[] { @this }.Concat(arguments).ToArray());
 }

        private JsExpression CreateMethodInfo(IMethodSymbol method, bool constructor = false)
        {
            JsExpression methodAttributes;
            switch (method.DeclaredAccessibility)
            {
                case Accessibility.Public:
                    methodAttributes = GetEnumValue(Context.Instance.MethodAttributesPublic);
                    break;
                case Accessibility.Internal:
                    methodAttributes = GetEnumValue(Context.Instance.MethodAttributesAssembly);
                    break;
                case Accessibility.Private:
                    methodAttributes = GetEnumValue(Context.Instance.MethodAttributesPrivate);
                    break;
                case Accessibility.Protected:
                    methodAttributes = GetEnumValue(Context.Instance.MethodAttributesFamily);
                    break;
                case Accessibility.ProtectedOrInternal:
                    methodAttributes = GetEnumValue(Context.Instance.MethodAttributesFamORAssem);
                    break;
                default:
                    throw new Exception();
            }
            if (method.IsStatic)
            {
                methodAttributes = EnumBitwise(SyntaxKind.BitwiseOrExpression, Context.Instance.MethodAttributes, 
                    methodAttributes, GetEnumValue(Context.Instance.MethodAttributesStatic));
            }

            var returnType = method.ReturnType;

            JsExpression info = constructor ?
                CreateObject(Context.Instance.ConstructorInfoConstructor,
                    Js.Primitive(method.GetMemberName()),
                    GetMethodFunction(method, true),
                    CreateParameterInfos(method.Parameters.ToArray()),
                    methodAttributes,
                    CreateAttributes(method)) :
                CreateObject(Context.Instance.MethodInfoConstructor,
                    Js.Primitive(method.MetadataName),
                    GetMethodFunction(method, true),
                    CreateParameterInfos(method.Parameters.ToArray()),
                    Type(returnType),
                    methodAttributes,
                    CreateAttributes(method));

            if (method.TypeParameters.Any())
            {
                var block = new JsBlockStatement();
                foreach (var typeParameter in method.TypeParameters)
                {
                    block.Local(
                        typeParameter.Name, 
                        Js.Reference(SpecialNames.DefineTypeParameter).Invoke(
                            Js.Reference(SpecialNames.Assembly),
                            Js.Primitive(typeParameter.Name), 
                            Type(typeParameter.BaseType ?? Context.Instance.ObjectType, true)));
                }
                block.Return(info);
                info = Wrap(block);
            }

            return info;
        }

 public JsStatement MapInterfaceMethod(JsExpression assignee, IMethodSymbol interfaceMethod, JsExpression implementation)
 {
     return assignee.Member(interfaceMethod.GetMemberName()).Assign(implementation).Express();
 }

 public JsStatement CreateInterfaceMethod(IMethodSymbol method)
 {
     return Js.This().Member(method.GetMemberName()).Invoke(method.Parameters.Select(x => Js.Reference(JsNames.EscapeIfReservedWord(x.Name))).ToArray()).Return();
 }