/// <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); } }
// 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); } } }
// 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)); }
/// <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); }
public static string GetTypeName(this ITypeReference type, NameFormattingOptions options) { TypeNameFormatter formatter = new TypeNameFormatter(); string name = formatter.GetTypeName(type, options); return(name); }
// 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(); }
/// <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); } }
// 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()); }
/// <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()); }
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(')'); }
/// <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(' '); }
/// <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); }
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)); }
/// <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); }
/// <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); }
private string GetTypeName(ITypeReference type) { NameFormattingOptions formattingOptions = NameFormattingOptions.TypeParameters | NameFormattingOptions.UseTypeKeywords; if (!_forCompilation) { formattingOptions |= NameFormattingOptions.OmitContainingNamespace; } return(GetTypeName(type, formattingOptions)); }
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); }
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); }
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(); } }
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); }
/// <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()); }
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)); }
/// <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(">"); }
/// <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)); }
// 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); } } }
/// <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(']'); } }
protected virtual void AppendMethodModifiers(IMethodReference method, NameFormattingOptions formattingOptions, StringBuilder sb) { }
// 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)); }
// ".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"); }
/// <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(')'); }
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(")"); }
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); } }
/// <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)); }