コード例 #1
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Appends the method name, optionally including the containing type name and using special names for methods with IsSpecialName set to true.
        /// </summary>
        protected virtual void AppendMethodName(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            if ((formattingOptions & NameFormattingOptions.OmitContainingType) == 0)
            {
                sb.Append(_typeNameFormatter.GetTypeName(method.ContainingType, formattingOptions));
                sb.Append('.');
            }
            // Special name translation
            string methodName = method.Name.Value;

            if (method.ResolvedMethod.IsSpecialName && (formattingOptions & NameFormattingOptions.PreserveSpecialNames) == 0)
            {
                if (methodName.StartsWith("get_"))
                {
                    //^ assume methodName.Length >= 4;
                    sb.Append(methodName.Substring(4));
                    sb.Append(".get");
                }
                else if (methodName.StartsWith("set_"))
                {
                    //^ assume methodName.Length >= 4;
                    sb.Append(methodName.Substring(4));
                    sb.Append(".set");
                }
                else
                {
                    sb.Append(methodName);
                }
            }
            else
            {
                sb.Append(methodName);
            }
        }
コード例 #2
0
        // Append "@" to a byref param's type
        protected override void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            // HACK: This is to support CCI1 syntax where generic type arguments are not shown for nested types.
            if (param.Type is INestedTypeReference)
            {
                formattingOptions = formattingOptions | NameFormattingOptions.OmitTypeArguments;
            }

            base.AppendParameter(param, (formattingOptions & ~NameFormattingOptions.OmitContainingType), sb);

            if (param.IsByReference)
            {
                sb.Append('@');
            }

            if (param.IsModified)
            {
                int count = 0;
                foreach (ICustomModifier modifier in param.CustomModifiers)
                {
                    count++;
                    //if (count>1)
                    //{ throw new NotImplementedException("Can't create a signature with more than one custom modifier"); }
                    AppendCustomModifier(formattingOptions, sb, modifier);
                }
            }
        }
コード例 #3
0
        // Append return type only on op_Explicit methods
        protected override void AppendReturnTypeSignature(ISignature sig, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            if ((formattingOptions & NameFormattingOptions.ReturnType) == 0)
            {
                return;
            }
            ITypeMemberReference member = sig as ITypeMemberReference;

            // TODO: Review
            //if (sig.CallingConvention != CallingConvention.Default)
            //{
            //    sb.Append(' ');
            //    sb.Append(sig.CallingConvention);
            //}
            if (sig.ReturnValueIsModified)
            {
                foreach (ICustomModifier modifier in sig.ReturnValueCustomModifiers)
                {
                    AppendCustomModifier(formattingOptions, sb, modifier);
                }
            }
            //===========

            if (member == null || (member.Name.Value != "op_Explicit" && member.Name.Value != "op_Implicit"))
            {
                return;
            }

            sb.Append(" : ");
            sb.Append(_formatter.GetTypeName(sig.Type, formattingOptions & ~NameFormattingOptions.OmitContainingType));
        }
コード例 #4
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Returns a C#-like string that corresponds to the given type member definition and that conforms to the specified formatting options.
        /// </summary>
        //^ [Pure]
        public virtual string GetMemberSignature(ITypeMemberReference member, NameFormattingOptions formattingOptions)
        {
            IMethodReference /*?*/ method = member as IMethodReference;

            if (method != null)
            {
                return(this.GetMethodSignature(method, formattingOptions));
            }
            ITypeReference /*?*/ type = member as ITypeReference;

            if (type != null)
            {
                return(_typeNameFormatter.GetTypeName(type, formattingOptions));
            }
            IEventDefinition /*?*/ eventDef = member as IEventDefinition;

            if (eventDef != null)
            {
                return(this.GetEventSignature(eventDef, formattingOptions));
            }
            IFieldReference /*?*/ field = member as IFieldReference;

            if (field != null)
            {
                return(this.GetFieldSignature(field, formattingOptions));
            }
            IPropertyDefinition /*?*/ property = member as IPropertyDefinition;

            if (property != null)
            {
                return(this.GetPropertySignature(property, formattingOptions));
            }
            return(member.Name.Value);
        }
コード例 #5
0
ファイル: TypeExtensions.cs プロジェクト: safern/buildtools
        public static string GetTypeName(this ITypeReference type, NameFormattingOptions options)
        {
            TypeNameFormatter formatter = new TypeNameFormatter();
            string            name      = formatter.GetTypeName(type, options);

            return(name);
        }
コード例 #6
0
 // Put return type after the signature
 public override string GetMethodSignature(IMethodReference method, NameFormattingOptions formattingOptions)
 {
     string baseSig = base.GetMethodSignature(method, (formattingOptions & ~NameFormattingOptions.ReturnType));
     StringBuilder sb = new StringBuilder(baseSig);
     AppendReturnTypeSignature(method, (formattingOptions | NameFormattingOptions.ReturnType), sb);
     return sb.ToString();
 }
コード例 #7
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Appends a formatted parameters.
        /// </summary>
        protected virtual void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            IParameterDefinition def = param as IParameterDefinition;

            if (def != null && (formattingOptions & NameFormattingOptions.ParameterModifiers) != 0)
            {
                if (def.IsOut)
                {
                    sb.Append("out ");
                }
                else if (def.IsParameterArray)
                {
                    sb.Append("params ");
                }
                else if (def.IsByReference)
                {
                    sb.Append("ref ");
                }
            }
            sb.Append(_typeNameFormatter.GetTypeName(param.Type, formattingOptions));
            if (def != null && (formattingOptions & NameFormattingOptions.ParameterName) != 0)
            {
                sb.Append(" ");
                sb.Append(def.Name.Value);
            }
        }
コード例 #8
0
        // Put return type after the signature
        public override string GetMethodSignature(IMethodReference method, NameFormattingOptions formattingOptions)
        {
            string        baseSig = base.GetMethodSignature(method, (formattingOptions & ~NameFormattingOptions.ReturnType));
            StringBuilder sb      = new StringBuilder(baseSig);

            AppendReturnTypeSignature(method, (formattingOptions | NameFormattingOptions.ReturnType), sb);
            return(sb.ToString());
        }
コード例 #9
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Returns a C#-like string that corresponds to the signature of the given property definition and that conforms to the specified formatting options.
        /// </summary>
        //^ [Pure]
        public virtual string GetPropertySignature(IPropertyDefinition property, NameFormattingOptions formattingOptions)
        {
            StringBuilder sb = new StringBuilder();

            this.AppendPropertyName(property, formattingOptions, sb);
            this.AppendPropertyParameters(property.Parameters, formattingOptions, sb);
            return(sb.ToString());
        }
コード例 #10
0
 private void AppendCustomModifier(NameFormattingOptions formattingOptions, StringBuilder sb, ICustomModifier modifier)
 {
     sb.Append(' ');
     sb.Append(modifier.IsOptional ? "modopt" : "modreq");
     sb.Append('(');
     sb.Append(_formatter.GetTypeName(modifier.Modifier, formattingOptions & ~NameFormattingOptions.OmitContainingType));
     sb.Append(')');
 }
コード例 #11
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
 /// <summary>
 /// Formats the return type of a signature
 /// </summary>
 protected virtual void AppendReturnTypeSignature(ISignature sig, NameFormattingOptions formattingOptions, StringBuilder sb)
 {
     if ((formattingOptions & NameFormattingOptions.ReturnType) == 0)
     {
         return;
     }
     sb.Append(_typeNameFormatter.GetTypeName(sig.Type, formattingOptions));
     sb.Append(' ');
 }
コード例 #12
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
 /// <summary>
 /// Appends the method name, optionally including the containing type name.
 /// </summary>
 protected virtual void AppendPropertyName(IPropertyDefinition property, NameFormattingOptions formattingOptions, StringBuilder sb)
 {
     if ((formattingOptions & NameFormattingOptions.OmitContainingType) == 0)
     {
         sb.Append(_typeNameFormatter.GetTypeName(property.ContainingType, formattingOptions));
         sb.Append(".");
     }
     //TODO: if property name appears in a default members attribute of the containing type and not PreserveSpecialNames, use "this"
     sb.Append(property.Name.Value);
 }
コード例 #13
0
        public override string GetValue(MemberMapping mapping)
        {
            var typeDefinitionMember            = mapping.Representative;
            const NameFormattingOptions options = NameFormattingOptions.OmitContainingNamespace |
                                                  NameFormattingOptions.OmitContainingType |
                                                  NameFormattingOptions.TypeParameters |
                                                  NameFormattingOptions.Signature;

            return(MemberHelper.GetMemberSignature(typeDefinitionMember, options));
        }
コード例 #14
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Returns a C#-like string that corresponds to the signature of the given field and that conforms to the specified formatting options.
        /// </summary>
        //^ [Pure]
        public virtual string GetFieldSignature(IFieldReference field, NameFormattingOptions formattingOptions)
        {
            string result = field.Name.Value;

            if ((formattingOptions & NameFormattingOptions.OmitContainingType) == 0)
            {
                result = _typeNameFormatter.GetTypeName(field.ContainingType, formattingOptions) + "." + result;
            }
            return(result);
        }
コード例 #15
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Returns a C#-like string that corresponds to the signature of the given event definition and that conforms to the specified formatting options.
        /// </summary>
        //^ [Pure]
        public virtual string GetEventSignature(IEventDefinition eventDef, NameFormattingOptions formattingOptions)
        {
            string result = eventDef.Name.Value;

            if ((formattingOptions & NameFormattingOptions.OmitContainingType) == 0)
            {
                result = _typeNameFormatter.GetTypeName(eventDef.ContainingType, formattingOptions) + "." + result;
            }
            return(result);
        }
コード例 #16
0
        private string GetTypeName(ITypeReference type)
        {
            NameFormattingOptions formattingOptions = NameFormattingOptions.TypeParameters | NameFormattingOptions.UseTypeKeywords;

            if (!_forCompilation)
            {
                formattingOptions |= NameFormattingOptions.OmitContainingNamespace;
            }

            return(GetTypeName(type, formattingOptions));
        }
コード例 #17
0
        private string GetTypeName(ITypeReference type)
        {
            Contract.Requires(type != null);
            NameFormattingOptions namingOptions = NameFormattingOptions.TypeParameters | NameFormattingOptions.UseTypeKeywords;

            if (!_forCompilation)
            {
                namingOptions |= NameFormattingOptions.OmitContainingNamespace;
            }

            string name = TypeHelper.GetTypeName(type, namingOptions);

            return(name);
        }
コード例 #18
0
ファイル: TypeExtensions.cs プロジェクト: safern/buildtools
        public static string GetTypeName(this ITypeReference type, bool includeNamespace = true)
        {
            TypeNameFormatter     formatter = new TypeNameFormatter();
            NameFormattingOptions options   = NameFormattingOptions.OmitTypeArguments | NameFormattingOptions.UseReflectionStyleForNestedTypeNames;

            if (!includeNamespace)
            {
                options |= NameFormattingOptions.OmitContainingNamespace;
            }

            string name = formatter.GetTypeName(type, options);

            return(name);
        }
コード例 #19
0
        private void WriteTypeName(ITypeReference type, bool noSpace = false, bool isDynamic = false, bool useTypeKeywords = true, bool omitGenericTypeList = false)
        {
            if (isDynamic)
            {
                WriteKeyword("dynamic", noSpace: noSpace);
                return;
            }

            NameFormattingOptions namingOptions = NameFormattingOptions.TypeParameters;

            if (useTypeKeywords)
            {
                namingOptions |= NameFormattingOptions.UseTypeKeywords;
            }

            if (_forCompilationIncludeGlobalprefix)
            {
                namingOptions |= NameFormattingOptions.UseGlobalPrefix;
            }

            if (!_forCompilation)
            {
                namingOptions |= NameFormattingOptions.OmitContainingNamespace;
            }

            if (omitGenericTypeList)
            {
                namingOptions |= NameFormattingOptions.EmptyTypeParameterList;
            }

            string name = TypeHelper.GetTypeName(type, namingOptions);

            if (CSharpCciExtensions.IsKeyword(name))
            {
                _writer.WriteKeyword(name);
            }
            else
            {
                _writer.WriteTypeName(name);
            }

            if (!noSpace)
            {
                WriteSpace();
            }
        }
コード例 #20
0
 private int WriteTypeNameRecursive(ITypeReference type, NameFormattingOptions namingOptions,
                                    string[] valueTupleNames, ref int valueTupleNameIndex, ref int nullableIndex, object nullableAttributeArgument, object dynamicAttributeArgument,
                                    int typeDepth = 0, int genericParameterIndex = 0, bool isValueTupleParameter = false)
 {
     void WriteTypeNameInner(ITypeReference typeReference)
     {
         if (IsDynamicType(dynamicAttributeArgument, typeDepth))
         {
             _writer.WriteKeyword("dynamic");
         }
         else
         {
             string name;
             if (typeReference is INestedTypeReference nestedType && (namingOptions & NameFormattingOptions.OmitTypeArguments) != 0)
             {
                 name  = TypeHelper.GetTypeName(nestedType.ContainingType, namingOptions & ~NameFormattingOptions.OmitTypeArguments);
                 name += ".";
                 name += TypeHelper.GetTypeName(nestedType, namingOptions | NameFormattingOptions.OmitContainingType);
             }
コード例 #21
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Returns a C#-like string that corresponds to the signature of the given method and that conforms to the specified formatting options.
        /// </summary>
        //^ [Pure]
        public virtual string GetMethodSignature(IMethodReference method, NameFormattingOptions formattingOptions)
        {
            StringBuilder sb = new StringBuilder();

            this.AppendReturnTypeSignature(method, formattingOptions, sb);
            this.AppendMethodName(method, formattingOptions, sb);
            IGenericMethodInstanceReference /*?*/ genericMethodInstance = method as IGenericMethodInstanceReference;

            if (genericMethodInstance != null)
            {
                this.AppendGenericArguments(genericMethodInstance, formattingOptions, sb);
            }
            else if (method.IsGeneric)
            {
                this.AppendGenericParameters(method, formattingOptions, sb);
            }
            this.AppendMethodParameters(method.Parameters, formattingOptions, sb);
            return(sb.ToString());
        }
コード例 #22
0
 private string GetTypeName(ITypeReference type, NameFormattingOptions formattingOptions)
 {
     if ((formattingOptions & NameFormattingOptions.UseTypeKeywords) != 0)
     {
         if (TypeHelper.TypesAreEquivalent(type, type.PlatformType.SystemIntPtr))
         {
             if ((LangVersion >= LangVersion11_0) || type.Attributes.HasNativeIntegerAttribute())
             {
                 return("nint");
             }
         }
         else if (TypeHelper.TypesAreEquivalent(type, type.PlatformType.SystemUIntPtr))
         {
             if ((LangVersion >= LangVersion11_0) || type.Attributes.HasNativeIntegerAttribute())
             {
                 return("nuint");
             }
         }
     }
     return(TypeHelper.GetTypeName(type, formattingOptions));
 }
コード例 #23
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Appends a formatted string of type parameters. Enclosed in angle brackets and comma-delimited.
        /// </summary>
        protected virtual void AppendGenericParameters(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            if ((formattingOptions & NameFormattingOptions.TypeParameters) == 0)
            {
                return;
            }
            sb.Append("<");
            bool   first = true;
            string delim = ((formattingOptions & NameFormattingOptions.OmitWhiteSpaceAfterListDelimiter) == 0) ? ", " : ",";

            foreach (ITypeReference argument in method.ResolvedMethod.GenericParameters)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    sb.Append(delim);
                }
                sb.Append(_typeNameFormatter.GetTypeName(argument, formattingOptions));
            }
            sb.Append(">");
        }
コード例 #24
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
 /// <summary>
 /// Returns a C#-like string that corresponds to the given type member definition and that conforms to the specified formatting options.
 /// </summary>
 //^ [Pure]
 public static string GetMemberSignature(ITypeMemberReference member, NameFormattingOptions formattingOptions)
 {
     return(new SignatureFormatter().GetMemberSignature(member, formattingOptions));
 }
コード例 #25
0
        // Append "@" to a byref param's type
        protected override void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            // HACK: This is to support CCI1 syntax where generic type arguments are not shown for nested types.
            if (param.Type is INestedTypeReference) formattingOptions = formattingOptions | NameFormattingOptions.OmitTypeArguments;

            base.AppendParameter(param, (formattingOptions & ~NameFormattingOptions.OmitContainingType), sb);

            if (param.IsByReference) sb.Append('@');

            if (param.IsModified)
            {
                int count = 0;
                foreach (ICustomModifier modifier in param.CustomModifiers)
                {
                    count++;
                    //if (count>1)
                    //{ throw new NotImplementedException("Can't create a signature with more than one custom modifier"); }
                    AppendCustomModifier(formattingOptions, sb, modifier);
                }
            }
        }
コード例 #26
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Appends a formatted string of parameters. Enclosed in square brackets and comma-delimited.
        /// </summary>
        protected virtual void AppendPropertyParameters(IEnumerable <IParameterDefinition> parameters, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            if ((formattingOptions & NameFormattingOptions.Signature) == 0)
            {
                return;
            }
            bool isNotEmpty = IteratorHelper.EnumerableIsNotEmpty(parameters);

            if (isNotEmpty)
            {
                sb.Append('[');
            }
            bool first = true;

            foreach (IParameterTypeInformation param in parameters)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    sb.Append(',');
                }
                this.AppendParameter(param, formattingOptions, sb);
            }
            if (isNotEmpty)
            {
                sb.Append(']');
            }
        }
コード例 #27
0
 protected virtual void AppendMethodModifiers(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb)
 {
 }
コード例 #28
0
        // Append return type only on op_Explicit methods
        protected override void AppendReturnTypeSignature(ISignature sig, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            if ((formattingOptions & NameFormattingOptions.ReturnType) == 0) return;
            ITypeMemberReference member = sig as ITypeMemberReference;
            // TODO: Review
            //if (sig.CallingConvention != CallingConvention.Default)
            //{
            //    sb.Append(' ');
            //    sb.Append(sig.CallingConvention);
            //}
            if (sig.ReturnValueIsModified)
            {
                foreach (ICustomModifier modifier in sig.ReturnValueCustomModifiers)
                {
                    AppendCustomModifier(formattingOptions, sb, modifier);
                }
            }
            //===========

            if (member == null || (member.Name.Value != "op_Explicit" && member.Name.Value != "op_Implicit")) return;

            sb.Append(" : ");
            sb.Append(_formatter.GetTypeName(sig.Type, formattingOptions & ~NameFormattingOptions.OmitContainingType));
        }
コード例 #29
0
 // ".ctor" -> "#ctor". NOTE: ".cctor" is unchanged
 protected override void AppendMethodName(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb)
 {
     base.AppendMethodName(method, formattingOptions, sb);
     sb.Replace(".ctor", "#ctor");
 }
コード例 #30
0
 private void AppendCustomModifier(NameFormattingOptions formattingOptions, StringBuilder sb, ICustomModifier modifier)
 {
     sb.Append(' ');
     sb.Append(modifier.IsOptional ? "modopt" : "modreq");
     sb.Append('(');
     sb.Append(_formatter.GetTypeName(modifier.Modifier, formattingOptions & ~NameFormattingOptions.OmitContainingType));
     sb.Append(')');
 }
コード例 #31
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
        /// <summary>
        /// Appends a formatted string of parameters. Enclosed in parentheses and comma-delimited.
        /// </summary>
        protected virtual void AppendMethodParameters(IEnumerable <IParameterTypeInformation> parameters, NameFormattingOptions formattingOptions, StringBuilder sb)
        {
            if ((formattingOptions & NameFormattingOptions.Signature) == 0)
            {
                return;
            }
            sb.Append('(');
            bool   first = true;
            string delim = ((formattingOptions & NameFormattingOptions.OmitWhiteSpaceAfterListDelimiter) == 0) ? ", " : ",";

            foreach (IParameterTypeInformation par in parameters)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    sb.Append(delim);
                }
                this.AppendParameter(par, formattingOptions, sb);
            }
            sb.Append(')');
        }
コード例 #32
0
        private void WriteTypeName(ITypeReference type, bool noSpace = false, IEnumerable <ICustomAttribute> attributes = null, bool useTypeKeywords = true,
                                   bool omitGenericTypeList          = false)
        {
            if (attributes != null && IsDynamic(attributes))
            {
                WriteKeyword("dynamic", noSpace: noSpace);
                return;
            }

            NameFormattingOptions namingOptions = NameFormattingOptions.TypeParameters | NameFormattingOptions.ContractNullable;

            if (useTypeKeywords)
            {
                namingOptions |= NameFormattingOptions.UseTypeKeywords;
            }

            if (_forCompilationIncludeGlobalprefix)
            {
                namingOptions |= NameFormattingOptions.UseGlobalPrefix;
            }

            if (!_forCompilation)
            {
                namingOptions |= NameFormattingOptions.OmitContainingNamespace;
            }

            if (omitGenericTypeList)
            {
                namingOptions |= NameFormattingOptions.EmptyTypeParameterList;
            }

            void WriteTypeNameInner(ITypeReference typeReference)
            {
                string name = TypeHelper.GetTypeName(typeReference, namingOptions);

                if (CSharpCciExtensions.IsKeyword(name))
                {
                    _writer.WriteKeyword(name);
                }
                else
                {
                    _writer.WriteTypeName(name);
                }
            }

            var definition = type.GetDefinitionOrNull();

            if (definition is IGenericTypeInstance genericType && genericType.IsValueTuple())
            {
                string[] names = attributes.GetValueTupleNames();

                _writer.WriteSymbol("(");

                int i = 0;
                foreach (var parameter in genericType.GenericArguments)
                {
                    if (i != 0)
                    {
                        _writer.WriteSymbol(",");
                        _writer.WriteSpace();
                    }

                    WriteTypeNameInner(parameter);

                    if (names?[i] != null)
                    {
                        _writer.WriteSpace();
                        _writer.WriteIdentifier(names[i]);
                    }

                    i++;
                }

                _writer.WriteSymbol(")");
            }
コード例 #33
0
        public virtual void PrintMethodReferenceName(IMethodReference methodReference, NameFormattingOptions options)
        {
            Contract.Requires(methodReference != null);

            string signature = MemberHelper.GetMethodSignature(methodReference, options | NameFormattingOptions.ContractNullable | NameFormattingOptions.UseTypeKeywords);

            if (signature.EndsWith(".get") || signature.EndsWith(".set"))
            {
                signature = signature.Substring(0, signature.Length - 4);
            }
            if (methodReference.Name.Value == ".ctor")
            {
                PrintTypeReferenceName(methodReference.ContainingType);
            }
            else
            {
                sourceEmitterOutput.Write(signature);
            }
        }
コード例 #34
0
 protected virtual void AppendMethodModifiers(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb)
 {
 }
コード例 #35
0
ファイル: MemberHelper.cs プロジェクト: VE-2016/VE-2016
 /// <summary>
 /// Returns a C#-like string that corresponds to the given method definition and that conforms to the specified formatting options.
 /// </summary>
 //^ [Pure]
 public static string GetMethodSignature(IMethodReference method, NameFormattingOptions formattingOptions)
 {
     return(new SignatureFormatter().GetMethodSignature(method, formattingOptions));
 }
コード例 #36
0
 // ".ctor" -> "#ctor". NOTE: ".cctor" is unchanged
 protected override void AppendMethodName(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb)
 {
     base.AppendMethodName(method, formattingOptions, sb);
     sb.Replace(".ctor", "#ctor");
 }