Beispiel #1
0
        /// <summary>
        /// 规范化成员名称选项.
        /// </summary>
        /// <param name="options">选项.</param>
        /// <returns>返回规范后的结果.</returns>
        public static MemberNameOptions NormMemberNameOptions(MemberNameOptions options)
        {
            MemberNameOptions rt = options;

            if (0 != (options & MemberNameOptions.TypeParamActual))
            {
                rt |= MemberNameOptions.TypeParam;
            }
            if (0 != (options & MemberNameOptions.TypeParam))
            {
                rt |= MemberNameOptions.TypeParamSeparator;
            }
            if (0 != (options & MemberNameOptions.TypeParamSeparator))
            {
                rt |= MemberNameOptions.TypeParamBracket;
            }
            if (0 != (options & (MemberNameOptions.ParamType | MemberNameOptions.ParamName)))
            {
                rt |= MemberNameOptions.ParamSeparator;
            }
            if (0 != (options & MemberNameOptions.ParamSeparator))
            {
                rt |= MemberNameOptions.ParamBracket;
            }
            return(rt);
        }
Beispiel #2
0
        /// <summary>
        /// 计算事件名称.
        /// </summary>
        /// <param name="mi">Event info.</param>
        /// <param name="options">Options.</param>
        /// <returns>返回名称, 失败时返回 null.</returns>
        public static string GetMemberName(EventInfo mi, MemberNameOptions options)
        {
            if (null == mi)
            {
                return(null);
            }
            string rt = mi.Name;

            options = NormMemberNameOptions(options);
            //TODO: 支持全部的 MemberNameOptions . By EventInfo.
            return(rt);
        }
Beispiel #3
0
        /// <summary>
        /// 计算方法名称.
        /// </summary>
        /// <param name="mi">Method info.</param>
        /// <param name="options">Options.</param>
        /// <returns>返回名称, 失败时返回 null.</returns>
        public static string GetMemberName(MethodInfo mi, MemberNameOptions options)
        {
            if (null == mi)
            {
                return(null);
            }
            string rt = mi.Name;

            options = NormMemberNameOptions(options);
            if (0 != (options & MemberNameOptions.ParamBracket))
            {
                rt = rt + "()";
            }
            //TODO: 支持全部的 MemberNameOptions . By MethodInfo.
            return(rt);
        }
Beispiel #4
0
        /// <summary>
        /// 计算类型名称.
        /// </summary>
        /// <param name="mi">Type.</param>
        /// <param name="options">Options.</param>
        /// <returns>返回名称, 失败时返回 null.</returns>
        public static string GetMemberName(Type mi, MemberNameOptions options)
        {
            if (null == mi)
            {
                return(null);
            }
            string rt = mi.Name;

            options = NormMemberNameOptions(options);
            if (0 != (options & MemberNameOptions.FullName))
            {
                rt = mi.FullName;
            }
            //TODO: 支持全部的 MemberNameOptions . By Type.
            return(rt);
        }
Beispiel #5
0
        /// <summary>
        /// 自动计算成员名称.
        /// </summary>
        /// <param name="mi">Member info.</param>
        /// <param name="options">Options.</param>
        /// <returns>返回名称, 失败时返回 null.</returns>
        public static string GetMemberNameAuto(MemberInfo mi, MemberNameOptions options)
        {
            if (null == mi)
            {
                return(null);
            }
            string rt = null;

            if (false)
            {
            }
            else if (mi is FieldInfo)
            {
                rt = GetMemberName(mi as FieldInfo, options);
            }
            else if (mi is PropertyInfo)
            {
                rt = GetMemberName(mi as PropertyInfo, options);
            }
            else if (mi is MethodInfo)
            {
                rt = GetMemberName(mi as MethodInfo, options);
            }
            else if (mi is EventInfo)
            {
                rt = GetMemberName(mi as EventInfo, options);
            }
#if (!NETFX_CORE)
            else if (mi is Type)
            {
                rt = GetMemberName(mi as Type, options);
            }
#endif
            else
            {
                rt = mi.Name;
            }
            return(rt);
        }
Beispiel #6
0
 public static string GetMemberName(Member m, MemberNameOptions givenOptions, Scope scope) {
   if (m is KeywordCompletion)
     return m.Name.Name;
   StringBuilder sb = new StringBuilder();
   if (IsOptionActive(givenOptions, MemberNameOptions.Access)){
     sb.Append(MemberNameBuilder.GetMemberAccessString(m));
     sb.Append(' ');
   }
   if (IsOptionActive(givenOptions, MemberNameOptions.Modifiers)) {
     if (m.IsStatic)
       sb.Append("static ");
   }
   sb.Append(MemberNameBuilder.GetMemberNameRaw(m, givenOptions, scope));
   return sb.ToString();
 }
Beispiel #7
0
 internal static string GetMethodName(Method method, MemberNameOptions givenOptions, Scope scope, out bool isIndexer) {
   string methName = null;
   isIndexer = false;
   if ( method.Template != null)
     methName = MemberNameBuilder.GetAtPrefixedIfRequired(method.Template.GetUnmangledNameWithoutTypeParameters(true), givenOptions);
   else
     methName = MemberNameBuilder.GetAtPrefixedIfRequired(method.GetUnmangledNameWithoutTypeParameters(true), givenOptions);
   if (method is InstanceInitializer) {
     MemberNameOptions mask = MemberNameOptions.Keywords | MemberNameOptions.TemplateInfo | MemberNameOptions.TemplateArguments | MemberNameOptions.TemplateParameters | MemberNameOptions.Namespace | MemberNameOptions.EnclosingType;
     methName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions & ~mask, scope);
   } else if (method.IsSpecialName) {
     if (methName.StartsWith("get_") || methName.StartsWith("set_")) {
       if ((method.Parameters != null && method.Parameters.Count > 0)) {
         //  In this case enclosing type is not really an option. its part of name.
         methName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions, scope);
         if (methName == null)
           methName = "";
         isIndexer = true;
       }
       methName = methName.Substring(4);
     } else if (methName.StartsWith("add_") && method.Parameters != null && method.Parameters.Count == 1)
       methName = methName.Substring(4);
     else if (methName.StartsWith("remove_") && method.Parameters != null && method.Parameters.Count == 1)
       methName = methName.Substring(7);
     else {
       string opName = method.Name == null ? null : (string)Cci.Checker.OperatorName[method.Name.UniqueIdKey];
       if (opName != null) {
         //  In this case Enclosing type is not really an option. its part of name.
         string name = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions, scope) + "." + opName;
         if (method.Name.UniqueIdKey == StandardIds.opExplicit.UniqueIdKey || method.Name.UniqueIdKey == StandardIds.opImplicit.UniqueIdKey)
           name = name + " " + MemberNameBuilder.GetMemberNameRaw(method.ReturnType, givenOptions, scope);
         return name;
       }
     }
   } else {
     if (method.HasCompilerGeneratedSignature) {
       if (method.Name.UniqueIdKey == StandardIds.Finalize.UniqueIdKey)
         methName = "~" + MemberNameBuilder.GetAtPrefixedIfRequired(method.DeclaringType.Name.Name, givenOptions);
     }
   }
   if (method.ImplementedTypes != null && method.ImplementedTypes.Count > 0 && method.ImplementedTypes[0] != null && IsOptionActive(givenOptions, MemberNameOptions.ImplementInterface))
     methName = MemberNameBuilder.GetMemberNameRaw(method.ImplementedTypes[0], givenOptions, scope) + "." + methName;
   if (IsOptionActive(givenOptions, MemberNameOptions.EnclosingType) && !isIndexer) {
     string decTypeName = null;
     if (!IsOptionActive(givenOptions, MemberNameOptions.SmartClassName) || !MemberNameBuilder.IsAggregateVisibleIn(method.DeclaringType, scope))
       decTypeName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions, scope); ;
     if (decTypeName != null)
       methName = decTypeName + "." + methName;
   }
   return methName;
 }
Beispiel #8
0
 internal static string GetMemberNameRaw(Member m, MemberNameOptions givenOptions, Scope scope) {
   TypeNode typeNode = m as TypeNode;
   if (typeNode != null) {
     if (typeNode.Name == Looker.NotFound) return "";
     if (IsOptionActive(givenOptions, MemberNameOptions.ExpandNullable) && typeNode.Template == SystemTypes.GenericNullable && typeNode.TemplateArguments != null
       && typeNode.TemplateArguments.Count > 0) {
       return MemberNameBuilder.GetMemberNameRaw(typeNode.TemplateArguments[0], givenOptions, scope) + "?";
     }
     if (IsOptionActive(givenOptions, MemberNameOptions.Keywords)) {
       switch (typeNode.TypeCode) {
         case TypeCode.Boolean: return "bool";
         case TypeCode.Byte: return "byte";
         case TypeCode.Char: return "char";
         case TypeCode.Decimal: return "decimal";
         case TypeCode.Double: return "double";
         case TypeCode.Int16: return "short";
         case TypeCode.Int32: return "int";
         case TypeCode.Int64: return "long";
         case TypeCode.SByte: return "sbyte";
         case TypeCode.Single: return "float";
         case TypeCode.String: return "string";
         case TypeCode.UInt16: return "ushort";
         case TypeCode.UInt32: return "uint";
         case TypeCode.UInt64: return "ulong";
       }
       if (typeNode == SystemTypes.Object) return "object";
       if (typeNode == SystemTypes.Void) return "void";
     }
     switch (typeNode.NodeType) {
       case NodeType.ArrayType: {
           ArrayType aType = (ArrayType)typeNode;
           StringBuilder sb = new StringBuilder(MemberNameBuilder.GetMemberNameRaw(aType.ElementType, givenOptions, scope));
           sb.Append('[');
           for (int i = 0, n = aType.Rank; i < n; i++) {
             if (i == 0 && n > 1) sb.Append('*');
             if (i < n - 1) {
               sb.Append(',');
               if (n > 1) sb.Append('*');
             }
           }
           sb.Append(']');
           return sb.ToString();
       }
       case NodeType.ConstrainedType:
       case NodeType.DelegateNode:
       case NodeType.EnumNode:
       case NodeType.Interface:
       case NodeType.TypeAlias:
       case NodeType.Class:{
         FunctionType fType = typeNode as FunctionType;
         if (fType != null) {
           return "delegate " + MemberNameBuilder.GetMemberNameRaw(fType.ReturnType, givenOptions, scope)
             + " " + MemberNameBuilder.GetSignatureString(fType.Parameters, "(", ")", ", ", givenOptions, scope, false);
         }
         ClosureClass cClass = typeNode as ClosureClass;
         if (cClass != null) {
           MemberList mems = cClass.Members;
           for (int i = 0, n = mems == null ? 0 : mems.Count; i < n; i++) {
             Method meth = mems[i] as Method;
             if (meth == null || meth is InstanceInitializer || (meth.Parameters != null && meth.Parameters.Count != 0)) continue;
             return MemberNameBuilder.GetMemberNameRaw(meth.ReturnType, givenOptions, scope);
           }
         }
         StringBuilder sb = new StringBuilder();
         if (IsOptionActive(givenOptions, MemberNameOptions.Namespace) && typeNode.Namespace != null) {
           string prefix = typeNode.Namespace.Name + ".";
           if (IsOptionActive(givenOptions, MemberNameOptions.SmartNamespaceName) && MemberNameBuilder.IsNamespaceImportedByScope(typeNode.Namespace, scope))
             prefix = "";
           sb.Append(MemberNameBuilder.GetAtPrefixedIfRequired(prefix, givenOptions));
         }
         if (IsOptionActive(givenOptions, MemberNameOptions.EnclosingType) && m.DeclaringType != null) {
           string prefix = "";
           if (!IsOptionActive(givenOptions, MemberNameOptions.SmartClassName) || !MemberNameBuilder.IsAggregateVisibleIn(m.DeclaringType, scope))
             prefix = MemberNameBuilder.GetMemberNameRaw(typeNode.DeclaringType, givenOptions, scope) + "."; ;
           sb.Append(MemberNameBuilder.GetAtPrefixedIfRequired(prefix, givenOptions));
         }
         string typeName = MemberNameBuilder.GetAtPrefixedIfRequired(typeNode.GetUnmangledNameWithoutTypeParameters(), givenOptions);
         if (IsOptionActive(givenOptions, MemberNameOptions.SupressAttributeSuffix) && typeName.EndsWith("Attribute")) {
           typeName = MemberNameBuilder.GetAtPrefixedIfRequired(typeName.Substring(0, typeName.Length - 9), givenOptions);
         }
         sb.Append(typeName);
         if (typeNode.TemplateParameters != null && typeNode.TemplateParameters.Count > 0) {
           if (IsOptionActive(givenOptions, MemberNameOptions.TemplateInfo))
             sb.Append("<>");
           else if(IsOptionActive(givenOptions, MemberNameOptions.TemplateParameters)){
             sb.Append('<');
             int n = typeNode.TemplateParameters.Count;
             for (int i = 0; i < n; i++) {
               sb.Append(MemberNameBuilder.GetMemberNameRaw(typeNode.TemplateParameters[i], givenOptions, scope));
               if (i < n - 1) sb.Append(',');
             }
             sb.Append('>');
           }
         } else if (typeNode.Template != null && typeNode.TemplateArguments != null && typeNode.TemplateArguments.Count > 0
           && IsOptionActive(givenOptions, MemberNameOptions.TemplateArguments)) {
           sb.Append('<');
           int n = typeNode.TemplateArguments.Count;
           for (int i = 0; i < n; i++) {
             sb.Append(MemberNameBuilder.GetMemberNameRaw(typeNode.TemplateArguments[i], givenOptions | MemberNameOptions.Keywords, scope));
             if (i < n - 1) sb.Append(',');
           }
           sb.Append('>');
         }
         return sb.ToString();
       }
       case NodeType.OptionalModifier:
         if (((OptionalModifier)typeNode).Modifier == SystemTypes.NonNullType)
           return MemberNameBuilder.GetMemberNameRaw(((OptionalModifier)typeNode).ModifiedType, givenOptions, scope) + "!";
         goto case NodeType.RequiredModifier;
       case NodeType.RequiredModifier:
         return MemberNameBuilder.GetMemberNameRaw(((TypeModifier)typeNode).ModifiedType, givenOptions, scope);
       case NodeType.Pointer:
         return MemberNameBuilder.GetMemberNameRaw(((Pointer)typeNode).ElementType, givenOptions, scope) + "*";
       case NodeType.Reference:
         return "ref " + MemberNameBuilder.GetMemberNameRaw(((Reference)typeNode).ElementType, givenOptions, scope);
       case NodeType.Refanytype:
       case NodeType.Struct:
         goto case NodeType.Class;
       case NodeType.ClassParameter:
       case NodeType.TypeParameter:
         return MemberNameBuilder.GetAtPrefixedIfRequired(typeNode.Name.ToString(), givenOptions);
       case NodeType.ClassExpression:
       case NodeType.InterfaceExpression:
       case NodeType.TypeExpression:
       case NodeType.ArrayTypeExpression:
       case NodeType.FlexArrayTypeExpression:
       case NodeType.FunctionTypeExpression:
       case NodeType.PointerTypeExpression:
       case NodeType.ReferenceTypeExpression:
       case NodeType.StreamTypeExpression:
       case NodeType.NonEmptyStreamTypeExpression:
       case NodeType.NonNullTypeExpression:
       case NodeType.NonNullableTypeExpression:
       case NodeType.BoxedTypeExpression:
       case NodeType.NullableTypeExpression:
       case NodeType.InvariantTypeExpression:
       case NodeType.TupleTypeExpression:
       case NodeType.TypeIntersectionExpression:
       case NodeType.TypeUnionExpression:
         return typeNode.SourceContext.SourceText;
     }
   }
   Method method = m as Method;
   if (method != null) {
     if (method is InstanceInitializer && method.DeclaringType is DelegateNode) return MemberNameBuilder.GetDelegateConstructorSignature(method, givenOptions, scope);
     StringBuilder sb = new StringBuilder();
     if (IsOptionActive(givenOptions, MemberNameOptions.PutReturnType) && !(method is InstanceInitializer)) {
       sb.Append(MemberNameBuilder.GetMemberNameRaw(method.ReturnType, givenOptions, scope));
       sb.Append(' ');
     }
     bool isIndexer;
     sb.Append(MemberNameBuilder.GetMethodName(method, givenOptions, scope, out isIndexer));
     if (method.TemplateParameters != null && method.TemplateParameters.Count > 0) {
       if (IsOptionActive(givenOptions, MemberNameOptions.TemplateInfo))
         sb.Append("<>");
       else if (IsOptionActive(givenOptions, MemberNameOptions.TemplateParameters)) {
         sb.Append('<');
         int n = method.TemplateParameters.Count;
         for (int i = 0; i < n; i++) {
           sb.Append(MemberNameBuilder.GetMemberNameRaw(method.TemplateParameters[i], givenOptions, scope));
           if (i < n - 1) sb.Append(',');
         }
         sb.Append('>');
       }
     } else if (method.Template != null && method.TemplateArguments != null && method.TemplateArguments.Count > 0
       && IsOptionActive(givenOptions, MemberNameOptions.TemplateArguments)) {
       sb.Append('<');
       int n = method.TemplateArguments.Count;
       for (int i = 0; i < n; i++) {
         sb.Append(MemberNameBuilder.GetMemberNameRaw(method.TemplateArguments[i], givenOptions | MemberNameOptions.Keywords, scope));
         if (i < n - 1) sb.Append(',');
       }
       sb.Append('>');
     }
     if (IsOptionActive(givenOptions, MemberNameOptions.PutSignature)) {
       InstanceInitializer ctor = method as InstanceInitializer;
       bool addNamedParameters = false;
       if (ctor != null) {
         MemberList ml = ctor.GetAttributeConstructorNamedParameters();
         addNamedParameters = ml != null && ml.Count > 0;
       }
       sb.Append(MemberNameBuilder.GetSignatureString(method.Parameters, isIndexer ? "[" : "(", isIndexer ? "]" : ")", ", ", givenOptions, scope, addNamedParameters));
     }
     if (IsOptionActive(givenOptions, MemberNameOptions.PutMethodConstraints) && method.TemplateParameters != null && method.TemplateParameters.Count > 0) {
       TypeNodeList templParameterList = method.TemplateParameters;
       int n = templParameterList.Count;
       for (int i = 0; i < n; i++) {
         TypeNode templParameter = templParameterList[i];
         ITypeParameter tpar = templParameter as ITypeParameter;
         if (!HasConstraints(templParameter, tpar) ) continue;
         sb.AppendFormat(" where {0} :", templParameter.Name.Name);
         bool isFirst = true;
         switch (tpar.TypeParameterFlags & TypeParameterFlags.SpecialConstraintMask) {
           case TypeParameterFlags.DefaultConstructorConstraint:
             sb.Append(" new()");
             isFirst = false;
             break;
           case TypeParameterFlags.ReferenceTypeConstraint:
             sb.Append(" class");
             isFirst = false;
             break;
           case TypeParameterFlags.ValueTypeConstraint:
             sb.Append(" struct");
             isFirst = false;
             break;
         }
         if (templParameter.BaseType != null && templParameter.BaseType != SystemTypes.Object) {
           if (isFirst)
             sb.Append(' ');
           else
             sb.Append(", ");
           sb.Append(MemberNameBuilder.GetMemberNameRaw(templParameterList[i].BaseType, givenOptions, scope));
           isFirst = false;
         }
         if (templParameter.Interfaces != null && templParameter.Interfaces.Count > 0) {
           InterfaceList interfaceList = templParameter.Interfaces;
           int n2 = interfaceList.Count;
           for (int j = 0; j < n2; ++j) {
             if (interfaceList[i] == null) continue;
             if (isFirst)
               sb.Append(' ');
             else
               sb.Append(", ");
             sb.Append(MemberNameBuilder.GetMemberNameRaw(interfaceList[i], givenOptions, scope));
             isFirst = false;
           }
         }
       }
     }
     return sb.ToString();
   }
   Property p = m as Property;
   if (p != null) {
     StringBuilder sb = new StringBuilder();
     if (IsOptionActive(givenOptions, MemberNameOptions.PutReturnType)) {
       sb.Append(MemberNameBuilder.GetMemberNameRaw(p.Type, givenOptions, scope));
       sb.Append(' ');
     }
     string name = null;
     bool isIndexer = false;
     if (p.DeclaringType.DefaultMembers.Contains(p)) {
       name = MemberNameBuilder.GetMemberNameRaw(p.DeclaringType, givenOptions, scope);
       isIndexer = true;
     } else
       name = MemberNameBuilder.GetAtPrefixedIfRequired(p.Name.ToString(), givenOptions);
       if (IsOptionActive(givenOptions, MemberNameOptions.EnclosingType) && !isIndexer) {
         string decTypeName = null;
         if (!IsOptionActive(givenOptions, MemberNameOptions.SmartClassName) || !MemberNameBuilder.IsAggregateVisibleIn(p.DeclaringType, scope))
           decTypeName = MemberNameBuilder.GetMemberNameRaw(p.DeclaringType, givenOptions, scope); ;
         if (decTypeName != null) {
           sb.Append(decTypeName);
           sb.Append(".");
         }
     }
     sb.Append(name);
     if (IsOptionActive(givenOptions, MemberNameOptions.PutSignature))
       sb.Append(MemberNameBuilder.GetSignatureString(p.Parameters, isIndexer ? "[" : "(", isIndexer ? "]" : ")", ", ", givenOptions, scope, false));
     return sb.ToString();
   }
   if (m==null || m.Name == null) return " ";
   return MemberNameBuilder.GetAtPrefixedIfRequired(m.Name.ToString(), givenOptions);
 }
Beispiel #9
0
 internal static string GetSignatureString(ParameterList parameters, string startPars, string endPars, string parSep, MemberNameOptions givenOpts, Scope scope, bool addNamedParameters) {
   StringBuilder sb = new StringBuilder(256);
   sb.Append(startPars);
   int n = parameters == null ? 0 : parameters.Count;
   for (int i = 0; i < n; i++) {
     Parameter p = parameters[i];
     sb.Append(GetParameterTypeName(p, givenOpts, scope));
     if (i < n - 1) sb.Append(parSep);
   }
   if (addNamedParameters) {
     string namedParamters = SpecSharpErrorNode.ResourceManager.GetString("NamedParameters", CultureInfo.CurrentCulture);
     if ( n > 0 ){
       sb.Append(parSep);
       sb.Append(namedParamters);
     }else{
       sb.Append(namedParamters);
     }
   }
   sb.Append(endPars);
   return sb.ToString();
 }
Beispiel #10
0
 public static string GetParameterTypeName(Parameter parameter, MemberNameOptions givenOptions, Scope scope) {
   if (parameter == null) return "";
   Reference r = parameter.Type as Reference;
   TypeNode typeNode = null;
   StringBuilder sb = new StringBuilder();
   string backUpName = null;
   if (r != null) {
     if ((parameter.Flags & ParameterFlags.Out) != 0) {
       if ( IsOptionActive(givenOptions, MemberNameOptions.PutParameterModifiers) ) sb.Append("out ");
       typeNode = r.ElementType;
     } else {
       if (IsOptionActive(givenOptions, MemberNameOptions.PutParameterModifiers)) sb.Append("ref ");
       typeNode = r.ElementType;
     }
   } else if (parameter.GetParamArrayElementType() != null) {
     if (IsOptionActive(givenOptions, MemberNameOptions.PutParameterModifiers)) sb.Append("params ");
     typeNode = parameter.Type;
   } else {
     typeNode = parameter.Type;
     if (typeNode == null && parameter.TypeExpression != null)
         backUpName = parameter.TypeExpression.SourceContext.SourceText;
   }
   sb.Append(backUpName != null ? MemberNameBuilder.GetAtPrefixedIfRequired(backUpName, givenOptions) : GetMemberNameRaw(typeNode, givenOptions, scope));
   if (IsOptionActive(givenOptions, MemberNameOptions.PutParameterName) && parameter.Name!= null) {
     sb.Append(' ');
     sb.Append(MemberNameBuilder.GetAtPrefixedIfRequired(parameter.Name.ToString(), givenOptions));
   }
   return sb.ToString();
 }
Beispiel #11
0
 internal static string GetDelegateConstructorSignature(Method method, MemberNameOptions givenOptions, Scope scope) {
   DelegateNode del = method.DeclaringType as DelegateNode;
   if (del == null) return "";
   StringBuilder sb = new StringBuilder();
   sb.Append(MemberNameBuilder.GetMemberNameRaw(del, givenOptions, scope));
   MemberNameOptions mask = MemberNameOptions.Keywords | MemberNameOptions.TemplateInfo | MemberNameOptions.TemplateArguments | MemberNameOptions.TemplateParameters | MemberNameOptions.Namespace | MemberNameOptions.EnclosingType;
   string methName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions & ~mask, scope);
   sb.Append('.');
   sb.Append(methName);
   sb.Append('(');
   sb.Append(MemberNameBuilder.GetMemberNameRaw(del.ReturnType, givenOptions, scope));
   sb.Append(MemberNameBuilder.GetSignatureString(del.Parameters, "(", ")", ", ", givenOptions&~MemberNameOptions.PutParameterName, scope, false));
   sb.Append(") target)");
   return sb.ToString();
 }
Beispiel #12
0
 internal static string GetAtPrefixedIfRequired(string name, MemberNameOptions opt) {
   if (name == null)
     return name;
   if ((opt & MemberNameOptions.AtPrefix) == MemberNameOptions.AtPrefix && Scanner.IsKeyword(name, false)) {
     return "@" + name;
   }
   return name;
 }
Beispiel #13
0
 internal static bool IsOptionActive(MemberNameOptions givenOpt, MemberNameOptions opt) {
   return (givenOpt & opt) == opt;
 }