protected override string GetFieldString(ICSharpCode.NRefactory.TypeSystem.IField field, OutputSettings settings)
{
if (field == null)
return "";
var result = new StringBuilder ();
bool isEnum = field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum;
AppendModifiers (result, settings, field);
if (!settings.CompletionListFomat && settings.IncludeReturnType && !isEnum) {
result.Append (GetTypeReferenceString (field.ReturnType, settings));
result.Append (settings.Markup (" "));
}
if (!settings.IncludeReturnType && settings.UseFullName) {
result.Append (GetTypeReferenceString (field.DeclaringTypeDefinition, settings));
result.Append (settings.Markup ("."));
}
result.Append (settings.EmitName (field, FilterName (Format (field.Name))));
if (settings.CompletionListFomat && settings.IncludeReturnType && !isEnum) {
result.Append (settings.Markup (" : "));
result.Append (GetTypeReferenceString (field.ReturnType, settings));
}
return result.ToString ();
}
static DomTypeNodeBuilder ()
{
DomTypeNodeBuilder.settings = new OutputSettings (OutputFlags.AssemblyBrowserDescription);
DomTypeNodeBuilder.settings.MarkupCallback += delegate (string text) {
return "<span style=\"text\">" + text + "</span>";
};
DomTypeNodeBuilder.settings.EmitModifiersCallback = delegate (string text) {
return "<span style=\"keyword.modifier\">" + text + "</span>";
};
DomTypeNodeBuilder.settings.EmitKeywordCallback = delegate (string text) {
return MarkupKeyword (text);
};
// DomTypeNodeBuilder.settings.EmitNameCallback = delegate (IEntity domVisitable, ref string outString) {
// if (domVisitable is IType) {
// outString = "<span style=\"text.link\"><u><a ref=\"" + ((IType)domVisitable).HelpUrl + "\">" + outString + "</a></u></span>";
// } else {
// outString = "<span style=\"text\">" + outString + "</span>";
// }
// };
// DomTypeNodeBuilder.settings.PostProcessCallback = delegate (IEntity domVisitable, ref string outString) {
// if (domVisitable is IReturnType) {
// outString = "<span style=\"text.link\"><u><a ref=\"" + ((IReturnType)domVisitable).HelpUrl + "\">" + outString + "</a></u></span>";
// }
// };
}
public override string GetString(string nameSpace, OutputSettings settings)
{
var result = new StringBuilder ();
result.Append (settings.EmitKeyword ("Namespace"));
result.Append (Format (nameSpace));
return result.ToString ();
}
protected override string GetConstructorString(IMethod method, OutputSettings settings)
{
var result = new StringBuilder ();
if (settings.IncludeModifiers)
AppendModifiers (result, settings, method);
result.Append (settings.EmitKeyword ("Constructor"));
result.Append (settings.EmitName (method, method.DeclaringType.Name));
if (settings.IncludeParameters) {
result.Append (settings.Markup ("("));
bool first = true;
foreach (var parameter in method.Parameters) {
if (!first)
result.Append (settings.Markup (", "));
result.Append (GetParameterString (method, parameter, settings));
first = false;
}
result.Append (settings.Markup (")"));
}
return result.ToString ();
}
protected override string GetIndexerString (IProperty property, OutputSettings settings)
{
if (property == null)
return "";
var result = new StringBuilder ();
AppendModifiers (result, settings, property);
if (settings.IncludeReturnType) {
result.Append (GetTypeReferenceString (property.ReturnType, settings));
result.Append (settings.Markup (" "));
}
if (!settings.IncludeReturnType && settings.UseFullName) {
result.Append (GetTypeReferenceString (property.DeclaringTypeDefinition, new OutputSettings (OutputFlags.UseFullName)));
result.Append (settings.Markup ("."));
}
AppendExplicitInterfaces (result, property, settings);
result.Append (settings.EmitName (property, Format ("this")));
if (settings.IncludeParameters && property.Getter.Parameters.Count > 0) {
result.Append (settings.Markup ("["));
AppendParameterList (result, settings, property.Getter.Parameters);
result.Append (settings.Markup ("]"));
}
if (settings.IncludeAccessor) {
result.Append (settings.Markup (" {"));
if (property.CanGet)
result.Append (settings.Markup (" get;"));
if (property.CanSet)
result.Append (settings.Markup (" set;"));
result.Append (settings.Markup (" }"));
}
return result.ToString ();
}
protected override string GetMethodString (IMethod method, OutputSettings settings)
{
return InternalGetMethodString (method, settings, settings.EmitName (method, Format (FilterName (method.EntityType == EntityType.Constructor || method.EntityType == EntityType.Destructor ? method.DeclaringTypeDefinition.Name : method.Name))), true);
}
protected override string GetOperatorString (IMethod method, OutputSettings settings)
{
return InternalGetMethodString (method, settings, settings.EmitName (method, Format (FilterName (method.Name))), true);
}
protected abstract string GetTypeString(IType type, OutputSettings settings);
protected override string GetTypeString (IType t, OutputSettings settings)
{
if (t.Kind == TypeKind.Unknown) {
return t.Name;
}
if (t.Kind == TypeKind.TypeParameter)
return t.FullName;
var typeWithElementType = t as TypeWithElementType;
if (typeWithElementType != null) {
var sb = new StringBuilder ();
if (typeWithElementType is PointerType) {
sb.Append (settings.Markup ("*"));
}
AppendType (sb, typeWithElementType.ElementType, settings);
if (typeWithElementType is ArrayType) {
sb.Append (settings.Markup ("["));
sb.Append (settings.Markup (new string (',', ((ArrayType)t).Dimensions - 1)));
sb.Append (settings.Markup ("]"));
}
return sb.ToString ();
}
ITypeDefinition type = t.GetDefinition ();
if (type == null)
return "";
if (!settings.UseNETTypeNames && type.Namespace == "System" && type.TypeParameterCount == 0) {
switch (type.Name) {
case "Object":
return "object";
case "Boolean":
return "bool";
case "Char":
return "char";
case "SByte":
return "sbyte";
case "Byte":
return "byte";
case "Int16":
return "short";
case "UInt16":
return "ushort";
case "Int32":
return "int";
case "UInt32":
return "uint";
case "Int64":
return "long";
case "UInt64":
return "ulong";
case "Single":
return "float";
case "Double":
return "double";
case "Decimal":
return "decimal";
case "String":
return "string";
case "Void":
return "void";
}
}
// output anonymous type
if (type.IsSynthetic && type.Name == "$Anonymous$")
return GetTypeReferenceString (type, settings);
var result = new StringBuilder ();
var def = type;
AppendModifiers (result, settings, def);
if (settings.IncludeKeywords)
result.Append (GetString (def.Kind));
if (result.Length > 0 && !result.ToString ().EndsWith (" "))
result.Append (settings.Markup (" "));
if (type.Kind == TypeKind.Delegate && settings.ReformatDelegates && settings.IncludeReturnType) {
var invoke = type.GetDelegateInvokeMethod ();
result.Append (GetTypeReferenceString (invoke.ReturnType, settings));
result.Append (settings.Markup (" "));
}
if (settings.UseFullInnerTypeName && type.DeclaringTypeDefinition != null) {
bool includeGenerics = settings.IncludeGenerics;
settings.OutputFlags |= OutputFlags.IncludeGenerics;
string typeString = GetTypeReferenceString (type.DeclaringTypeDefinition, settings);
if (!includeGenerics)
settings.OutputFlags &= ~OutputFlags.IncludeGenerics;
result.Append (typeString);
result.Append (settings.Markup ("."));
}
result.Append (settings.EmitName (type, type.Name));
if (settings.IncludeGenerics && type.TypeParameterCount > 0) {
result.Append (settings.Markup ("<"));
for (int i = 0; i < type.TypeParameterCount; i++) {
if (i > 0)
result.Append (settings.Markup (settings.HideGenericParameterNames ? "," : ", "));
if (!settings.HideGenericParameterNames) {
if (t is ParameterizedType) {
result.Append (GetTypeReferenceString (((ParameterizedType)t).TypeArguments [i], settings));
} else {
AppendVariance (result, type.TypeParameters [i].Variance);
result.Append (NetToCSharpTypeName (type.TypeParameters [i].FullName));
}
}
}
result.Append (settings.Markup (">"));
}
if (t.Kind == TypeKind.Delegate && settings.ReformatDelegates) {
// var policy = GetPolicy (settings);
// if (policy.BeforeMethodCallParentheses)
// result.Append (settings.Markup (" "));
result.Append (settings.Markup ("("));
var invoke = type.GetDelegateInvokeMethod ();
if (invoke != null)
AppendParameterList (result, settings, invoke.Parameters);
result.Append (settings.Markup (")"));
return result.ToString ();
}
if (settings.IncludeBaseTypes && type.DirectBaseTypes.Any ()) {
bool first = true;
foreach (var baseType in type.DirectBaseTypes) {
// if (baseType.FullName == "System.Object" || baseType.FullName == "System.Enum")
// continue;
result.Append (settings.Markup (first ? " : " : ", "));
first = false;
result.Append (GetTypeReferenceString (baseType, settings));
}
}
// OutputConstraints (result, settings, type.TypeParameters);
return result.ToString ();
}
protected abstract string GetConstructorString(IMethod constructor, OutputSettings settings);
protected abstract string GetEventString (IEvent evt, OutputSettings settings);
protected abstract string GetParameterString(IParameterizedMember member, IParameter parameter, OutputSettings settings);
public abstract string GetString(string nameSpace, OutputSettings settings);
protected abstract string GetEventString(IEvent evt, OutputSettings settings);
protected abstract string GetIndexerString(IProperty property, OutputSettings settings);
protected abstract string GetFieldString(IField field, OutputSettings settings);
protected abstract string GetOperatorString(IMethod op, OutputSettings settings);
protected abstract string GetDestructorString(IMethod destructor, OutputSettings settings);
void AppendExplicitInterfaces (StringBuilder sb, IMember member, OutputSettings settings)
{
if (member == null || !member.IsExplicitInterfaceImplementation)
return;
foreach (var implementedInterfaceMember in member.ImplementedInterfaceMembers) {
if (settings.UseFullName) {
sb.Append (Format (implementedInterfaceMember.DeclaringTypeDefinition.FullName));
} else {
sb.Append (Format (implementedInterfaceMember.DeclaringTypeDefinition.Name));
}
sb.Append (settings.Markup ("."));
}
}
protected abstract string GetOperatorString (IMethod op, OutputSettings settings);
void AppendParameter (OutputSettings settings, StringBuilder result, IParameter parameter)
{
if (parameter == null)
return;
if (parameter.IsOut) {
result.Append (settings.Markup ("out"));
result.Append (settings.Markup (" "));
} else if (parameter.IsRef) {
result.Append (settings.Markup ("ref"));
result.Append (settings.Markup (" "));
} else if (parameter.IsParams) {
result.Append (settings.Markup ("params"));
result.Append (settings.Markup (" "));
}
result.Append (GetParameterString (null, parameter, settings));
}
protected abstract string GetMethodString(IMethod method, OutputSettings settings);
protected abstract string GetDestructorString (IMethod destructor, OutputSettings settings);
protected abstract string GetParameterString (IParameterizedMember member, IParameter parameter, OutputSettings settings);
protected abstract string GetFieldString (IField field, OutputSettings settings);
public void AppendType (StringBuilder sb, IType type, OutputSettings settings)
{
if (type.Kind == TypeKind.Unknown) {
sb.Append (type.Name);
return;
}
if (type.Kind == TypeKind.TypeParameter) {
sb.Append (type.Name);
return;
}
if (type.DeclaringType != null) {
AppendType (sb, type.DeclaringType, settings);
sb.Append (settings.Markup ("."));
}
if (type.Namespace == "System" && type.TypeParameterCount == 0) {
switch (type.Name) {
case "Object":
sb.Append ("object");
return;
case "Boolean":
sb.Append ("bool");
return;
case "Char":
sb.Append ("char");
return;
case "SByte":
sb.Append ("sbyte");
return;
case "Byte":
sb.Append ("byte");
return;
case "Int16":
sb.Append ("short");
return;
case "UInt16":
sb.Append ("ushort");
return;
case "Int32":
sb.Append ("int");
return;
case "UInt32":
sb.Append ("uint");
return;
case "Int64":
sb.Append ("long");
return;
case "UInt64":
sb.Append ("ulong");
return;
case "Single":
sb.Append ("float");
return;
case "Double":
sb.Append ("double");
return;
case "Decimal":
sb.Append ("decimal");
return;
case "String":
sb.Append ("string");
return;
case "Void":
sb.Append ("void");
return;
}
}
var typeWithElementType = type as TypeWithElementType;
if (typeWithElementType != null) {
AppendType (sb, typeWithElementType.ElementType, settings);
if (typeWithElementType is PointerType) {
sb.Append (settings.Markup ("*"));
}
if (typeWithElementType is ArrayType) {
sb.Append (settings.Markup ("["));
sb.Append (settings.Markup (new string (',', ((ArrayType)type).Dimensions - 1)));
sb.Append (settings.Markup ("]"));
}
return;
}
var pt = type as ParameterizedType;
if (pt != null) {
if (pt.Name == "Nullable" && pt.Namespace == "System" && pt.TypeParameterCount == 1) {
AppendType (sb, pt.TypeArguments [0], settings);
sb.Append (settings.Markup ("?"));
return;
}
sb.Append (pt.Name);
if (pt.TypeParameterCount > 0) {
sb.Append (settings.Markup ("<"));
for (int i = 0; i < pt.TypeParameterCount; i++) {
if (i > 0)
sb.Append (settings.Markup (", "));
AppendType (sb, pt.TypeArguments [i], settings);
}
sb.Append (settings.Markup (">"));
}
return;
}
var typeDef = type as ITypeDefinition ?? type.GetDefinition ();
if (typeDef != null) {
sb.Append (typeDef.Name);
if (typeDef.TypeParameterCount > 0) {
sb.Append (settings.Markup ("<"));
for (int i = 0; i < typeDef.TypeParameterCount; i++) {
if (i > 0)
sb.Append (settings.Markup (", "));
AppendVariance (sb, typeDef.TypeParameters [i].Variance);
AppendType (sb, typeDef.TypeParameters [i], settings);
}
sb.Append (settings.Markup (">"));
}
}
}
protected abstract string GetIndexerString (IProperty property, OutputSettings settings);
protected abstract string GetTypeReferenceString(IType reference, OutputSettings settings);
public string CreateTooltip (MonoDevelop.Ide.Gui.Document doc, int offset, ResolveResult result, string errorInformations, Gdk.ModifierType modifierState)
{
try {
OutputSettings settings = new OutputSettings (OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
// Approximate value for usual case
StringBuilder s = new StringBuilder (150);
string documentation = null;
if (result != null) {
if (result is UnknownIdentifierResolveResult) {
s.Append (String.Format (GettextCatalog.GetString ("Unresolved identifier '{0}'"), ((UnknownIdentifierResolveResult)result).Identifier));
} else if (result.IsError) {
s.Append (GettextCatalog.GetString ("Resolve error."));
} else if (result is LocalResolveResult) {
var lr = (LocalResolveResult)result;
s.Append ("<small><i>");
s.Append (lr.IsParameter ? paramStr : localStr);
s.Append ("</i></small>\n");
s.Append (ambience.GetString (lr.Variable.Type, settings));
s.Append (" ");
s.Append (lr.Variable.Name);
} else if (result is MethodGroupResolveResult) {
var mrr = (MethodGroupResolveResult)result;
s.Append ("<small><i>");
s.Append (methodStr);
s.Append ("</i></small>\n");
var allMethods = new List<IMethod> (mrr.Methods);
foreach (var l in mrr.GetExtensionMethods ()) {
allMethods.AddRange (l);
}
var method = allMethods.FirstOrDefault ();
if (method != null) {
s.Append (GLib.Markup.EscapeText (CreateAmbience (doc, offset, method.Compilation).ConvertEntity (method)));
if (allMethods.Count > 1) {
int overloadCount = allMethods.Count - 1;
s.Append (string.Format (GettextCatalog.GetPluralString (" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
}
documentation = AmbienceService.GetDocumentationSummary (method);
}
} else if (result is MemberResolveResult) {
var member = ((MemberResolveResult)result).Member;
s.Append ("<small><i>");
s.Append (GetString (member));
s.Append ("</i></small>\n");
var field = member as IField;
if (field != null && field.IsConst) {
s.Append (GLib.Markup.EscapeText (CreateAmbience (doc, offset, field.Compilation).ConvertType (field.Type)));
s.Append (" ");
s.Append (field.Name);
s.Append (" = ");
s.Append (GetConst (field.ConstantValue));
s.Append (";");
} else {
s.Append (GLib.Markup.EscapeText (CreateAmbience (doc, offset, member.Compilation).ConvertEntity (member)));
}
documentation = AmbienceService.GetDocumentationSummary (member);
} else if (result is NamespaceResolveResult) {
s.Append ("<small><i>");
s.Append (namespaceStr);
s.Append ("</i></small>\n");
s.Append (ambience.GetString (((NamespaceResolveResult)result).NamespaceName, settings));
} else {
var tr = result;
var typeString = GetString (tr.Type);
if (!string.IsNullOrEmpty (typeString)) {
s.Append ("<small><i>");
s.Append (typeString);
s.Append ("</i></small>\n");
}
settings.OutputFlags |= OutputFlags.UseFullName;
s.Append (ambience.GetString (tr.Type, settings));
documentation = AmbienceService.GetDocumentationSummary (tr.Type.GetDefinition ());
}
if (!string.IsNullOrEmpty (documentation)) {
s.Append ("\n<small>");
s.Append (AmbienceService.GetDocumentationMarkup ("<summary>" + documentation + "</summary>"));
s.Append ("</small>");
}
}
if (!string.IsNullOrEmpty (errorInformations)) {
if (s.Length != 0)
s.Append ("\n\n");
s.Append ("<small>");
s.Append (errorInformations);
s.Append ("</small>");
}
return s.ToString ();
} catch (Exception e){
return e.ToString ();
}
}
protected override string GetParameterString(IParameterizedMember member, IParameter parameter, OutputSettings settings)
{
var result = new StringBuilder();
if (settings.IncludeParameterName)
{
result.Append(Format(parameter.Name));
if (settings.IncludeReturnType)
{
result.Append(settings.Markup(" : "));
result.Append(GetTypeReferenceString(parameter.Type, settings));
}
}
else
{
result.Append(GetTypeReferenceString(parameter.Type, settings));
}
if (parameter.IsRef || parameter.IsOut)
{
result.Append(settings.Markup("&"));
}
return(result.ToString());
}
protected override string GetTypeReferenceString (IType reference, OutputSettings settings)
{
if (reference == null)
return "null";
var type = reference;
if (type.Kind == TypeKind.Unknown) {
return reference.Name;
}
if (reference.Kind == TypeKind.TypeParameter)
return reference.FullName;
var sb = new StringBuilder ();
if (type is ITypeDefinition && ((ITypeDefinition)type).IsSynthetic && ((ITypeDefinition)type).Name == "$Anonymous$") {
sb.Append ("new {");
foreach (var property in ((ITypeDefinition)type).Properties) {
sb.AppendLine ();
sb.Append ("\t");
sb.Append (GetTypeReferenceString (property.ReturnType, settings) ?? "?");
sb.Append (" ");
sb.Append (property.Name);
sb.Append (";");
}
sb.AppendLine ();
sb.Append ("}");
return sb.ToString ();
}
AppendType (sb, type, settings);
return sb.ToString ();
}
protected override string GetTypeReferenceString(IType reference, OutputSettings settings)
{
return(reference.ToString());
}
string InternalGetMethodString (IMethod method, OutputSettings settings, string methodName, bool getReturnType)
{
if (method == null)
return "";
var result = new StringBuilder ();
AppendModifiers (result, settings, method);
if (!settings.CompletionListFomat && settings.IncludeReturnType && getReturnType) {
result.Append (GetTypeReferenceString (method.ReturnType, settings));
result.Append (settings.Markup (" "));
}
if (!settings.IncludeReturnType && settings.UseFullName) {
result.Append (GetTypeReferenceString (method.DeclaringTypeDefinition, new OutputSettings (OutputFlags.UseFullName)));
result.Append (settings.Markup ("."));
}
AppendExplicitInterfaces (result, method, settings);
if (method.EntityType == EntityType.Operator) {
result.Append ("operator ");
result.Append (settings.Markup (GetOperator (methodName)));
} else {
result.Append (methodName);
}
if (settings.IncludeGenerics) {
if (method.TypeParameters.Count > 0) {
result.Append (settings.Markup ("<"));
for (int i = 0; i < method.TypeParameters.Count; i++) {
if (i > 0)
result.Append (settings.Markup (settings.HideGenericParameterNames ? "," : ", "));
if (!settings.HideGenericParameterNames) {
AppendVariance (result, method.TypeParameters [i].Variance);
result.Append (NetToCSharpTypeName (method.TypeParameters [i].Name));
}
}
result.Append (settings.Markup (">"));
}
}
if (settings.IncludeParameters) {
// CSharpFormattingPolicy policy = GetPolicy (settings);
// if (policy.BeforeMethodCallParentheses)
// result.Append (settings.Markup (" "));
result.Append (settings.Markup ("("));
AppendParameterList (result, settings, method.Parameters);
result.Append (settings.Markup (")"));
}
if (settings.CompletionListFomat && settings.IncludeReturnType && getReturnType) {
result.Append (settings.Markup (" : "));
result.Append (GetTypeReferenceString (method.ReturnType, settings));
}
// OutputConstraints (result, settings, method.TypeParameters);
return result.ToString ();
}
public abstract string GetString (string nameSpace, OutputSettings settings);
protected override string GetDestructorString (IMethod method, OutputSettings settings)
{
return InternalGetMethodString (method, settings, settings.EmitName (method, settings.Markup ("~") + Format (FilterName (method.DeclaringTypeDefinition != null ? method.DeclaringTypeDefinition.Name : method.Name))), false);
}
protected abstract string GetTypeReferenceString (IType reference, OutputSettings settings);
protected override string GetEventString (IEvent evt, OutputSettings settings)
{
if (evt == null)
return "";
var result = new StringBuilder ();
AppendModifiers (result, settings, evt);
if (settings.IncludeKeywords)
result.Append (settings.EmitKeyword ("event"));
if (!settings.CompletionListFomat && settings.IncludeReturnType) {
result.Append (GetTypeReferenceString (evt.ReturnType, settings));
result.Append (settings.Markup (" "));
}
if (!settings.IncludeReturnType && settings.UseFullName) {
result.Append (GetTypeReferenceString (evt.DeclaringTypeDefinition, new OutputSettings (OutputFlags.UseFullName)));
result.Append (settings.Markup ("."));
}
AppendExplicitInterfaces (result, evt, settings);
result.Append (settings.EmitName (evt, Format (FilterName (evt.Name))));
if (settings.CompletionListFomat && settings.IncludeReturnType) {
result.Append (settings.Markup (" : "));
result.Append (GetTypeReferenceString (evt.ReturnType, settings));
}
return result.ToString ();
}
protected abstract string GetTypeString (IType type, OutputSettings settings);
protected override string GetParameterString (IParameterizedMember member, IParameter parameter, OutputSettings settings)
{
if (parameter == null)
return "";
var result = new StringBuilder ();
if (settings.IncludeParameterName) {
if (settings.IncludeModifiers) {
if (parameter.IsOut) {
result.Append (settings.EmitKeyword ("out"));
}
if (parameter.IsRef) {
result.Append (settings.EmitKeyword ("ref"));
}
if (parameter.IsParams) {
result.Append (settings.EmitKeyword ("params"));
}
}
result.Append (GetTypeReferenceString (parameter.Type, settings));
result.Append (" ");
if (settings.HighlightName) {
result.Append (settings.EmitName (parameter, settings.Highlight (Format (FilterName (parameter.Name)))));
} else {
result.Append (settings.EmitName (parameter, Format (FilterName (parameter.Name))));
}
} else {
result.Append (GetTypeReferenceString (parameter.Type, settings));
}
return result.ToString ();
}
protected abstract string GetMethodString (IMethod method, OutputSettings settings);
void AppendParameterList (StringBuilder result, OutputSettings settings, IEnumerable<IParameter> parameterList)
{
if (parameterList == null)
return;
bool first = true;
foreach (var parameter in parameterList) {
if (!first)
result.Append (settings.Markup (", "));
AppendParameter (settings, result, parameter);
first = false;
}
}
protected abstract string GetConstructorString (IMethod constructor, OutputSettings settings);
void AppendModifiers (StringBuilder result, OutputSettings settings, IEntity entity)
{
if (!settings.IncludeModifiers)
return;
if (entity.IsStatic)
result.Append (settings.EmitModifiers ("static"));
if (entity.IsSealed)
result.Append (settings.EmitModifiers ("sealed"));
if (entity.IsAbstract)
result.Append (settings.EmitModifiers ("abstract"));
if (entity.IsShadowing)
result.Append (settings.EmitModifiers ("new"));
switch (entity.Accessibility) {
case Accessibility.Internal:
result.Append (settings.EmitModifiers ("internal"));
break;
case Accessibility.ProtectedAndInternal:
result.Append (settings.EmitModifiers ("protected internal"));
break;
case Accessibility.ProtectedOrInternal:
result.Append (settings.EmitModifiers ("internal protected"));
break;
case Accessibility.Protected:
result.Append (settings.EmitModifiers ("protected"));
break;
case Accessibility.Private:
result.Append (settings.EmitModifiers ("private"));
break;
case Accessibility.Public:
result.Append (settings.EmitModifiers ("public"));
break;
}
}
public string GetString(IType type, OutputSettings settings)
{
var result = GetTypeString(type, settings);
return(settings.PostProcess(type, result));
}
