1090 lines
41 KiB
C#
1090 lines
41 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using Mono.Cecil;
|
|
using Mono.Collections.Generic;
|
|
using Mono.Documentation.Util;
|
|
|
|
namespace Mono.Documentation.Updater
|
|
{
|
|
public class FSharpFormatter : MemberFormatter
|
|
{
|
|
private static readonly Dictionary<string, string> operators = new Dictionary<string, string>()
|
|
{
|
|
{ "op_Nil" ,"[]" },
|
|
{ "op_Cons" ,"::" },
|
|
{ "op_Addition" ,"+" },
|
|
{ "op_Subtraction" ,"-" },
|
|
{ "op_Multiply" ,"*" },
|
|
{ "op_Division" ,"/" },
|
|
{ "op_Append" ,"@" },
|
|
{ "op_Concatenate" ,"^" },
|
|
{ "op_Modulus" ,"%" },
|
|
{ "op_BitwiseAnd" ,"&&&" },
|
|
{ "op_BitwiseOr" ,"|||" },
|
|
{ "op_ExclusiveOr" ,"^^^" },
|
|
{ "op_LeftShift" ,"<<<" },
|
|
{ "op_LogicalNot" ,"~~~" },
|
|
{ "op_RightShift" ,">>>" },
|
|
{ "op_UnaryPlus" ,"~+" },
|
|
{ "op_UnaryNegation" ,"~-" },
|
|
{ "op_Equality" ,"=" },
|
|
{ "op_LessThanOrEqual" ,"<=" },
|
|
{ "op_GreaterThanOrEqual" ,">=" },
|
|
{ "op_LessThan" ,"<" },
|
|
{ "op_GreaterThan" ,">" },
|
|
{ "op_Dynamic" ,"?" },
|
|
{ "op_DynamicAssignment" ,"?<-" },
|
|
{ "op_PipeRight" ,"|>" },
|
|
{ "op_PipeRight2" ,"||>" },
|
|
{ "op_PipeRight3" ,"|||>" },
|
|
{ "op_PipeLeft" ,"<|" },
|
|
{ "op_PipeLeft2" ,"<||" },
|
|
{ "op_PipeLeft3" ,"<|||" },
|
|
{ "op_Dereference" ,"!" },
|
|
{ "op_ComposeRight" ,">>" },
|
|
{ "op_ComposeLeft" ,"<<" },
|
|
{ "op_Quotation" ,"<@ @>" },
|
|
{ "op_QuotationUntyped" ,"<@@ @@>" },
|
|
{ "op_AdditionAssignment" ,"+=" },
|
|
{ "op_SubtractionAssignment" ,"-=" },
|
|
{ "op_MultiplyAssignment" ,"*=" },
|
|
{ "op_DivisionAssignment" ,"/=" },
|
|
{ "op_Range" ,".." },
|
|
{ "op_RangeStep" ,".. .." },
|
|
};
|
|
|
|
// Other combinations of operator characters that are not listed here can be used as operators and have names
|
|
// that are made up by concatenating names for the individual characters from the following table.
|
|
// For example, +! becomes op_PlusBang
|
|
private static readonly Dictionary<string, string> combinatedOperators = new Dictionary<string, string>()
|
|
{
|
|
{"Greater" , ">"},
|
|
{"Less" , "<"},
|
|
{"Plus" , "+"},
|
|
{"Minus" , "-"},
|
|
{"Multiply", "*"},
|
|
{"Equals" , "="},
|
|
{"Twiddle" , "~"},
|
|
{"Percent" , "%"},
|
|
{"Dot" , "."},
|
|
{"Amp" , "&"},
|
|
{"Bar" , "|"},
|
|
{"At" , "@"},
|
|
{"Hash" , "#"},
|
|
{"Hat" , "^"},
|
|
{"Bang" , "!"},
|
|
{"Qmark" , "?"},
|
|
{"Divide" , "/"},
|
|
{"Colon" , ":"},
|
|
{"LParen" , "("},
|
|
{"Comma" , ","},
|
|
{"RParen" , ")"},
|
|
{"LBrack" , "["},
|
|
{"RBrack" , "]"},
|
|
};
|
|
|
|
private static readonly Dictionary<string, string> typeAbbreviations = new Dictionary<string, string>()
|
|
{
|
|
{"System.Boolean", "bool"},
|
|
{"System.Byte", "byte"},
|
|
{"System.SByte", "sbyte"},
|
|
{"System.Int16", "int16"},
|
|
{"System.UInt16", "uint16"},
|
|
{"System.Int32", "int"},
|
|
{"System.UInt32", "uint32"},
|
|
{"System.Int64", "int64"},
|
|
{"System.UInt64", "uint64"},
|
|
{"System.IntPtr", "nativeint"},
|
|
{"System.UIntPtr", "unativeint"},
|
|
{"System.Char", "char"},
|
|
{"System.String", "string"},
|
|
{"System.Decimal", "decimal"},
|
|
{"System.Void", "unit"},
|
|
{"System.Single", "single"},// Can be float32
|
|
{"System.Double", "double"},// Can be float
|
|
{"System.Object", "obj"},
|
|
{"Microsoft.FSharp.Core.Unit", "unit"},
|
|
{"Microsoft.FSharp.Core.FSharpOption`1", "option"},
|
|
{"System.Collections.Generic.IEnumerable`1", "seq"},
|
|
{"Microsoft.FSharp.Core.FSharpRef`1", "ref"},
|
|
};
|
|
|
|
private static readonly HashSet<string> fSharpPrefixes = new HashSet<string>()
|
|
{
|
|
"Microsoft.FSharp.Collections.FSharp",
|
|
"Microsoft.FSharp.Core.FSharp",
|
|
"Microsoft.FSharp.Control.FSharp",
|
|
"Microsoft.FSharp.Data.FSharp",
|
|
"Microsoft.FSharp.Linq.FSharp",
|
|
"Microsoft.FSharp.NativeInterop.FSharp",
|
|
"Microsoft.FSharp.Quotations.FSharp",
|
|
"Microsoft.FSharp.Reflection.FSharp",
|
|
};
|
|
|
|
private static readonly HashSet<string> ignoredValueTypeInterfaces = new HashSet<string>()
|
|
{
|
|
"System.IEquatable`1",
|
|
"System.Collections.IStructuralEquatable",
|
|
"System.IComparable`1",
|
|
"System.IComparable",
|
|
"System.Collections.IStructuralComparable",
|
|
};
|
|
|
|
private GenericParameterState genericParameterState = GenericParameterState.None;
|
|
|
|
protected string GetFSharpType(TypeReference type)
|
|
{
|
|
string typeToCompare = type.FullName;
|
|
|
|
var fullName = type.IsGenericInstance ? type.GetElementType().FullName : type.FullName;
|
|
if (typeAbbreviations.ContainsKey(fullName))
|
|
{
|
|
typeToCompare = typeAbbreviations[fullName];
|
|
}
|
|
else
|
|
{
|
|
var prefixToRemove = fSharpPrefixes.FirstOrDefault(i => fullName.StartsWith(i));
|
|
if (prefixToRemove != null)
|
|
{
|
|
typeToCompare = base.AppendTypeName(new StringBuilder(), type.FullName.Replace(prefixToRemove, "")).ToString();
|
|
}
|
|
|
|
if (type.IsGenericParameter)
|
|
{
|
|
typeToCompare = GetGenericName(type.Name);
|
|
}
|
|
}
|
|
return typeToCompare == type.FullName ? null : typeToCompare;
|
|
}
|
|
|
|
protected override StringBuilder AppendTypeName(StringBuilder buf, TypeReference type, DynamicParserContext context)
|
|
{
|
|
string fSharpType = GetFSharpType(type);
|
|
if (fSharpType != null)
|
|
{
|
|
return buf.Append(fSharpType);
|
|
}
|
|
|
|
if (type.IsGenericParameter)
|
|
{
|
|
return buf.Append(GetGenericName(type.Name));
|
|
}
|
|
|
|
return base.AppendTypeName(buf, type, context);
|
|
}
|
|
|
|
protected override string GetTypeDeclaration(TypeDefinition type)
|
|
{
|
|
string visibility = GetTypeVisibility(type.Attributes);
|
|
if (visibility == null)
|
|
return null;
|
|
|
|
StringBuilder buf = new StringBuilder();
|
|
if (IsModule(type))
|
|
{
|
|
AppendModuleDeclaraion(buf, type);
|
|
return buf.ToString();
|
|
}
|
|
if (IsDiscriminatedUnionCase(type))
|
|
{
|
|
AppendDiscriminatedUnionCase(buf, type);
|
|
return buf.ToString();
|
|
}
|
|
|
|
buf.Append("type ");
|
|
buf.Append(visibility);
|
|
buf.Append(GetTypeName(type));
|
|
buf.Append(" = ");
|
|
|
|
if (IsRecord(type))
|
|
{
|
|
buf.Append("{}");
|
|
return buf.ToString();
|
|
}
|
|
|
|
if (IsDiscriminatedUnion(type))
|
|
{
|
|
return buf.ToString();
|
|
}
|
|
if (type.IsEnum)
|
|
{
|
|
return buf.ToString();
|
|
}
|
|
|
|
buf.Append($"{GetTypeKind(type)}");
|
|
|
|
if (DocUtils.IsDelegate(type))
|
|
{
|
|
buf.Append(" ");
|
|
MethodDefinition invoke = type.GetMethod("Invoke");
|
|
AppendFunctionSignature(buf, invoke);
|
|
return buf.ToString();
|
|
}
|
|
|
|
AppendBaseType(buf, type);
|
|
|
|
foreach (var interfaceImplementation in type.Interfaces)
|
|
{
|
|
var resolvedInterface = interfaceImplementation.InterfaceType.Resolve ();
|
|
|
|
if (type.IsValueType
|
|
&& ignoredValueTypeInterfaces.Any(i => interfaceImplementation.InterfaceType.FullName.StartsWith(i))
|
|
|| (resolvedInterface != null && resolvedInterface.IsNotPublic))
|
|
continue;
|
|
buf.Append($"{GetLineEnding()}{Consts.Tab}interface ");
|
|
AppendTypeName(buf, GetTypeName(interfaceImplementation.InterfaceType));
|
|
}
|
|
|
|
return buf.ToString();
|
|
}
|
|
|
|
private void AppendDiscriminatedUnionCase(StringBuilder buf, TypeDefinition type)
|
|
{
|
|
buf.Append(GetName(type));
|
|
buf.Append(" : ");
|
|
|
|
var constructor = type.Methods.First(i => i.Name == ".ctor");
|
|
AppendParameters(buf, constructor, constructor.Parameters);
|
|
buf.Append(" -> ");
|
|
buf.Append(GetName(type.DeclaringType));
|
|
}
|
|
|
|
private void AppendBaseType(StringBuilder buf, TypeDefinition type)
|
|
{
|
|
TypeReference basetype = type.BaseType;
|
|
if (basetype != null && basetype.FullName == "System.Object" || type.IsValueType)
|
|
basetype = null;
|
|
|
|
if (basetype != null)
|
|
{
|
|
buf.Append($"{GetLineEnding()}{Consts.Tab}inherit ");
|
|
buf.Append(GetName(basetype));
|
|
}
|
|
}
|
|
|
|
private void AppendFunctionSignature(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
bool isTuple = method.Parameters.Count == 1 && IsTuple(method.Parameters[0].ParameterType);
|
|
if (isTuple)
|
|
buf.Append("(");
|
|
AppendParameters(buf, method, method.Parameters);
|
|
if (isTuple)
|
|
buf.Append(")");
|
|
|
|
buf.Append(" -> ");
|
|
if (method.IsConstructor)
|
|
buf.Append(GetTypeName(method.DeclaringType));
|
|
else
|
|
{
|
|
if (IsFSharpFunction(method.ReturnType))
|
|
buf.Append("(");
|
|
buf.Append(GetTypeName(method.ReturnType));
|
|
if (IsFSharpFunction(method.ReturnType))
|
|
buf.Append(")");
|
|
}
|
|
}
|
|
|
|
private string GetTypeKind(TypeDefinition type)
|
|
{
|
|
if (type.IsInterface)
|
|
{
|
|
return "interface";
|
|
}
|
|
if (type.IsValueType)
|
|
{
|
|
return "struct";
|
|
}
|
|
if (DocUtils.IsDelegate(type))
|
|
{
|
|
return "delegate of";
|
|
}
|
|
return "class";
|
|
}
|
|
|
|
protected override StringBuilder AppendGenericType(StringBuilder buf, TypeReference type, DynamicParserContext context, bool appendGeneric = true)
|
|
{
|
|
List<TypeReference> decls = DocUtils.GetDeclaringTypes(
|
|
type is GenericInstanceType ? type.GetElementType() : type);
|
|
List<TypeReference> genArgs = GetGenericArguments(type);
|
|
int argIdx = 0;
|
|
int displayedInParentArguments = 0;
|
|
bool insertNested = false;
|
|
foreach (var decl in decls)
|
|
{
|
|
TypeReference declDef = decl.Resolve() ?? decl;
|
|
if (insertNested)
|
|
{
|
|
buf.Append(NestedTypeSeparator);
|
|
}
|
|
insertNested = true;
|
|
|
|
bool isTuple = IsTuple(type)
|
|
// If this is a declaration of `Tuple` type
|
|
// treat it as an ordinary type
|
|
&& !(type is TypeDefinition);
|
|
bool isFSharpFunction = IsFSharpFunction(type);
|
|
if (!isTuple && !isFSharpFunction)
|
|
AppendTypeName(buf, declDef, context);
|
|
|
|
int argumentCount = DocUtils.GetGenericArgumentCount(declDef);
|
|
int notYetDisplayedArguments = argumentCount - displayedInParentArguments;
|
|
displayedInParentArguments = argumentCount;// nested TypeReferences have parents' generic arguments, but we shouldn't display them
|
|
if (notYetDisplayedArguments > 0)
|
|
{
|
|
if (!isTuple && !isFSharpFunction)
|
|
buf.Append(GenericTypeContainer[0]);
|
|
if (isFSharpFunction && genericParameterState == GenericParameterState.WithinTuple)
|
|
buf.Append("(");
|
|
var origState = MemberFormatterState;
|
|
var genericParameterStateOrigState = genericParameterState;
|
|
MemberFormatterState = MemberFormatterState.WithinGenericTypeParameters;
|
|
genericParameterState = isTuple ? GenericParameterState.WithinTuple : GenericParameterState.None;
|
|
|
|
for (int i = 0; i < notYetDisplayedArguments; ++i)
|
|
{
|
|
if (i > 0)
|
|
buf.Append(isTuple ? " * " : isFSharpFunction ? " -> " : ", ");
|
|
var genArg = genArgs[argIdx++];
|
|
var genericParameter = genArg as GenericParameter;
|
|
if (genericParameter != null && IsFlexibleType(genericParameter))
|
|
{
|
|
buf.Append("#");// replace genericParameter which is a flexible type with its constraint type
|
|
#if NEW_CECIL
|
|
_AppendTypeName(buf, genericParameter.Constraints[0].ConstraintType, context);
|
|
#else
|
|
_AppendTypeName(buf, genericParameter.Constraints[0], context);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
_AppendTypeName(buf, genArg, context);
|
|
}
|
|
}
|
|
MemberFormatterState = origState;
|
|
genericParameterState = genericParameterStateOrigState;
|
|
|
|
if (MemberFormatterState == MemberFormatterState.None)
|
|
{
|
|
AppendConstraints(buf,
|
|
genArgs.GetRange(0, notYetDisplayedArguments)
|
|
.SafeCast<GenericParameter>()
|
|
.ToList());
|
|
}
|
|
if (!isTuple && !isFSharpFunction)
|
|
buf.Append(GenericTypeContainer[1]);
|
|
if (isFSharpFunction && genericParameterState == GenericParameterState.WithinTuple)
|
|
buf.Append(")");
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
private void AppendModuleDeclaraion(StringBuilder buf, TypeDefinition type)
|
|
{
|
|
buf.Append("module ");
|
|
buf.Append(GetModuleName(type));
|
|
}
|
|
|
|
private string GetModuleName(TypeDefinition type)
|
|
{
|
|
var moduleName = GetTypeName(type);
|
|
const string moduleKeyWord = "Module";
|
|
if (moduleName.EndsWith(moduleKeyWord))
|
|
{
|
|
moduleName = moduleName.Substring(0, moduleName.Length - moduleKeyWord.Length);
|
|
}
|
|
return moduleName;
|
|
}
|
|
|
|
protected override StringBuilder AppendGenericTypeConstraints(StringBuilder buf, TypeReference type)
|
|
{
|
|
return buf;
|
|
}
|
|
|
|
private void AppendConstraints(StringBuilder buf, IList<GenericParameter> genArgs)
|
|
{
|
|
var origMemberFormatterState = MemberFormatterState;
|
|
MemberFormatterState = MemberFormatterState.WithinGenericTypeParameters;
|
|
List<string> constraintStrings = new List<string>();
|
|
|
|
foreach (GenericParameter genArg in genArgs.Where(i => !IsFlexibleType(i)))
|
|
{
|
|
GenericParameterAttributes attrs = genArg.Attributes;
|
|
|
|
#if NEW_CECIL
|
|
Mono.Collections.Generic.Collection<GenericParameterConstraint> constraints = genArg.Constraints;
|
|
#else
|
|
IList<TypeReference> constraints = genArg.Constraints;
|
|
#endif
|
|
if (attrs == GenericParameterAttributes.NonVariant && constraints.Count == 0)
|
|
continue;
|
|
|
|
bool isref = (attrs & GenericParameterAttributes.ReferenceTypeConstraint) != 0;
|
|
bool isvt = (attrs & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0;
|
|
bool isnew = (attrs & GenericParameterAttributes.DefaultConstructorConstraint) != 0;
|
|
|
|
if (!isref && !isvt && !isnew && constraints.Count == 0)
|
|
continue;
|
|
|
|
var genericName = GetGenericName(genArg.Name);
|
|
if (isref)
|
|
{
|
|
// May be "not struct". We don't know it here
|
|
constraintStrings.Add($"{genericName} : null");
|
|
}
|
|
else if (isvt)
|
|
{
|
|
constraintStrings.Add($"{genericName} : struct");
|
|
}
|
|
if (constraints.Count > 0 && !isvt)
|
|
{
|
|
foreach (var typeReference in constraints)
|
|
{
|
|
#if NEW_CECIL
|
|
constraintStrings.Add($"{genericName} :> {GetTypeName(typeReference.ConstraintType)}");
|
|
#else
|
|
constraintStrings.Add($"{genericName} :> {GetTypeName(typeReference)}");
|
|
#endif
|
|
}
|
|
}
|
|
if (isnew && !isvt)
|
|
{
|
|
constraintStrings.Add($"{genericName} : (new : unit -> {GetTypeName(genArg)})");
|
|
}
|
|
}
|
|
|
|
if (constraintStrings.Count > 0)
|
|
{
|
|
buf.Append($" (requires {string.Join(" and ", constraintStrings)})");
|
|
}
|
|
MemberFormatterState = origMemberFormatterState;
|
|
}
|
|
|
|
protected override string GetConstructorDeclaration(MethodDefinition constructor)
|
|
{
|
|
StringBuilder buf = new StringBuilder();
|
|
if (constructor.Parameters.Count == 0)
|
|
return null;
|
|
if (AppendVisibility(buf, constructor) == null)
|
|
return null;
|
|
|
|
buf.Append("new ");
|
|
buf.Append(GetTypeName(constructor.DeclaringType));
|
|
buf.Append(" : ");
|
|
AppendFunctionSignature(buf, constructor);
|
|
|
|
return buf.ToString();
|
|
}
|
|
|
|
protected override string GetMethodDeclaration(MethodDefinition method)
|
|
{
|
|
var visibilityBuf = new StringBuilder();
|
|
if (AppendVisibility(visibilityBuf, method) == null)
|
|
return null;
|
|
|
|
string visibility = visibilityBuf.ToString();
|
|
StringBuilder buf = new StringBuilder();
|
|
var kind = GetMethodKind(method);
|
|
switch (kind)
|
|
{
|
|
case FSharpMethodKind.InModule:
|
|
AppendModuleMethod(buf, method);
|
|
break;
|
|
case FSharpMethodKind.Static:
|
|
AppendStaticMethod(buf, method, visibility);
|
|
break;
|
|
case FSharpMethodKind.Override:
|
|
AppendOverrideMethod(buf, method, visibility);
|
|
break;
|
|
case FSharpMethodKind.Abstract:
|
|
AppendAbstractMethod(buf, method, visibility);
|
|
break;
|
|
case FSharpMethodKind.Virtual:
|
|
AppendVirtualMethod(buf, method, visibility);
|
|
break;
|
|
case FSharpMethodKind.Common:
|
|
AppendCommonMethod(buf, method, visibility);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
|
|
return buf.ToString();
|
|
}
|
|
|
|
private FSharpMethodKind GetMethodKind(MethodDefinition method)
|
|
{
|
|
if (IsModule(method.DeclaringType))
|
|
return FSharpMethodKind.InModule;
|
|
if (method.IsStatic)
|
|
return FSharpMethodKind.Static;
|
|
if (IsOverride(method))
|
|
return FSharpMethodKind.Override;
|
|
if (method.IsAbstract)
|
|
return FSharpMethodKind.Abstract;
|
|
if (method.IsVirtual)
|
|
return FSharpMethodKind.Virtual;
|
|
|
|
return FSharpMethodKind.Common;
|
|
}
|
|
|
|
private void AppendModuleMethod(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
if (!IsOperator(method))
|
|
{
|
|
buf.Append($"{GetModuleName(method.DeclaringType)}.");
|
|
}
|
|
AppendMethodDeclarationEnding(buf, method);
|
|
}
|
|
|
|
private void AppendVirtualMethod(StringBuilder buf, MethodDefinition method, string visibility)
|
|
{
|
|
AppendAbstractMethod(buf, method, visibility);
|
|
buf.Append(GetLineEnding());
|
|
AppendOverrideMethod(buf, method, visibility);
|
|
}
|
|
|
|
private void AppendStaticMethod(StringBuilder buf, MethodDefinition method, string visibility)
|
|
{
|
|
buf.Append("static member ");
|
|
buf.Append(visibility);
|
|
AppendMethodDeclarationEnding(buf, method);
|
|
}
|
|
|
|
private void AppendAbstractMethod(StringBuilder buf, MethodDefinition method, string visibility)
|
|
{
|
|
buf.Append("abstract member ");
|
|
buf.Append(visibility);
|
|
AppendMethodDeclarationEnding(buf, method);
|
|
}
|
|
|
|
private void AppendOverrideMethod(StringBuilder buf, MethodDefinition method, string visibility)
|
|
{
|
|
buf.Append("override ");
|
|
buf.Append(visibility);
|
|
buf.Append("this.");
|
|
AppendMethodDeclarationEnding(buf, method);
|
|
}
|
|
|
|
private void AppendCommonMethod(StringBuilder buf, MethodDefinition method, string visibility)
|
|
{
|
|
buf.Append("member ");
|
|
buf.Append(visibility);
|
|
buf.Append("this.");
|
|
AppendMethodDeclarationEnding(buf, method);
|
|
}
|
|
|
|
private void AppendMethodDeclarationEnding(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
AppendMethodName(buf, method);
|
|
buf.Append(" : ");
|
|
AppendFunctionSignature(buf, method);
|
|
AppendConstraints(buf, method.GenericParameters);
|
|
}
|
|
|
|
protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
if (IsOperator(method))
|
|
{
|
|
// this is an operator
|
|
if (TryAppendOperatorName(buf, method))
|
|
return buf;
|
|
|
|
return base.AppendMethodName(buf, method);
|
|
}
|
|
|
|
var compilationSourceNameAttribute = method.CustomAttributes.FirstOrDefault
|
|
(i => i.AttributeType.FullName == "Microsoft.FSharp.Core.CompilationSourceNameAttribute");
|
|
if (compilationSourceNameAttribute != null)
|
|
return buf.Append(compilationSourceNameAttribute.ConstructorArguments.First().Value);
|
|
|
|
return buf.Append(method.Name);
|
|
}
|
|
|
|
protected override StringBuilder AppendGenericMethodConstraints(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
return buf;
|
|
}
|
|
|
|
protected override StringBuilder AppendRefTypeName(StringBuilder buf, TypeReference type, DynamicParserContext context)
|
|
{
|
|
return buf;
|
|
}
|
|
|
|
protected override StringBuilder AppendModifiers(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
return buf;
|
|
}
|
|
|
|
private bool IsOverride(MethodDefinition method)
|
|
{
|
|
return IsOverride(method.DeclaringType, method);
|
|
}
|
|
|
|
private bool IsOverride(TypeDefinition type, MethodDefinition method)
|
|
{
|
|
if (type == null || type.BaseType == null)
|
|
return false;
|
|
var baseType = type.BaseType.Resolve();
|
|
if (baseType != null && baseType.Methods.Any(i => i.Name == method.Name))
|
|
return true;
|
|
return IsOverride(type.BaseType.Resolve(), method);
|
|
}
|
|
|
|
protected override StringBuilder AppendGenericMethod(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
return buf;
|
|
}
|
|
|
|
protected void AppendRecordParameter(StringBuilder buf, PropertyDefinition property)
|
|
{
|
|
bool hasParameterName = !string.IsNullOrEmpty(property.Name);
|
|
if (property.SetMethod != null && property.SetMethod.IsPublic)
|
|
buf.Append("mutable ");
|
|
if (hasParameterName)
|
|
{
|
|
buf.Append(property.Name.TrimEnd('@'));
|
|
}
|
|
|
|
if (property.PropertyType.FullName != "System.Object")
|
|
{
|
|
var typeName = GetTypeName(property.PropertyType, new DynamicParserContext(property));
|
|
if (hasParameterName)
|
|
buf.Append(" : ");
|
|
buf.Append(typeName);
|
|
}
|
|
}
|
|
|
|
protected override StringBuilder AppendParameters(StringBuilder buf, MethodDefinition method, IList<ParameterDefinition> parameters)
|
|
{
|
|
var curryBorders = GetCurryBorders(method);
|
|
|
|
if (parameters.Count > 0)
|
|
{
|
|
bool isExtensionMethod = IsExtensionMethod(method);
|
|
if (!isExtensionMethod)
|
|
{// If it's an extension method, first parameter is ignored
|
|
AppendParameter(buf, parameters[0]);
|
|
}
|
|
for (int i = 1; i < parameters.Count; ++i)
|
|
{
|
|
if (!(isExtensionMethod && i == 1))
|
|
{
|
|
if (curryBorders.Contains(i))
|
|
buf.Append(" -> ");
|
|
else
|
|
buf.Append(" * ");
|
|
}
|
|
AppendParameter(buf, parameters[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
buf.Append("unit");
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
private void AppendParameter(StringBuilder buf, ParameterDefinition parameter)
|
|
{
|
|
bool isFSharpFunction = IsFSharpFunction(parameter.ParameterType);
|
|
if (isFSharpFunction)
|
|
buf.Append("(");
|
|
var typeName = GetTypeName(parameter.ParameterType, new DynamicParserContext(parameter));
|
|
buf.Append(typeName);
|
|
if (isFSharpFunction)
|
|
buf.Append(")");
|
|
}
|
|
|
|
protected override string GetPropertyDeclaration(PropertyDefinition property)
|
|
{
|
|
string getVisible = null;
|
|
if (DocUtils.IsAvailablePropertyMethod(property.GetMethod))
|
|
getVisible = AppendVisibility(new StringBuilder(), property.GetMethod)?.ToString();
|
|
string setVisible = null;
|
|
if (DocUtils.IsAvailablePropertyMethod(property.SetMethod))
|
|
setVisible = AppendVisibility(new StringBuilder(), property.SetMethod)?.ToString();
|
|
|
|
if (setVisible == null && getVisible == null)
|
|
return null;
|
|
|
|
bool isField = GetFSharpFlags(property.CustomAttributes).Any(i => i == SourceConstructFlags.Field);
|
|
StringBuilder buf = new StringBuilder();
|
|
|
|
if (IsRecord(property.DeclaringType))
|
|
{
|
|
AppendRecordParameter(buf, property);
|
|
return buf.ToString();
|
|
}
|
|
|
|
if (IsModule(property.DeclaringType))
|
|
{
|
|
buf.Append($"{GetName(property.DeclaringType)}.");
|
|
}
|
|
else
|
|
{
|
|
if (isField)
|
|
buf.Append("val ");
|
|
else
|
|
buf.Append("member this.");
|
|
}
|
|
|
|
buf.Append(DocUtils.GetPropertyName(property, NestedTypeSeparator));
|
|
if (property.Parameters.Count != 0)
|
|
{
|
|
buf.Append("(");
|
|
AppendParameters(buf, property.GetMethod ?? property.SetMethod, property.Parameters);
|
|
buf.Append(")");
|
|
}
|
|
buf.Append(" : ");
|
|
buf.Append(GetTypeName(property.PropertyType));
|
|
|
|
if (getVisible != null && setVisible != null)
|
|
{
|
|
buf.Append(" with get, set");
|
|
}
|
|
return buf.ToString();
|
|
}
|
|
|
|
protected override string GetFieldDeclaration(FieldDefinition field)
|
|
{
|
|
TypeDefinition declType = (TypeDefinition)field.DeclaringType;
|
|
if (declType.IsEnum && field.Name == "value__")
|
|
return null; // This member of enums aren't documented.
|
|
|
|
var visibility = GetFieldVisibility(field);
|
|
if (visibility == null)
|
|
return null;
|
|
var buf = new StringBuilder();
|
|
|
|
if (declType.IsEnum)
|
|
{
|
|
buf.Append(field.Name);
|
|
if (field.IsLiteral)
|
|
{
|
|
buf.Append($" = {field.Constant}");
|
|
}
|
|
return buf.ToString();
|
|
}
|
|
if (field.IsStatic && !field.IsLiteral)
|
|
buf.Append(" static");
|
|
|
|
buf.Append("val mutable");
|
|
if (!string.IsNullOrEmpty(visibility))
|
|
buf.Append(" ");
|
|
buf.Append(visibility);
|
|
buf.Append(" ");
|
|
buf.Append(field.Name);
|
|
buf.Append(" : ");
|
|
buf.Append(GetTypeName(field.FieldType, new DynamicParserContext(field)));
|
|
|
|
return buf.ToString();
|
|
}
|
|
|
|
protected override string GetEventDeclaration(EventDefinition e)
|
|
{
|
|
StringBuilder buf = new StringBuilder();
|
|
StringBuilder visibilityBuf = new StringBuilder();
|
|
if (AppendVisibility(visibilityBuf, e.AddMethod) == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
buf.Append("member this.");
|
|
if (visibilityBuf.Length > 0)
|
|
buf.Append(visibilityBuf).Append(' ');
|
|
buf.Append(e.Name).Append(" : ");
|
|
buf.Append(GetTypeName(e.EventType, new DynamicParserContext(e.AddMethod.Parameters[0]))).Append(' ');
|
|
|
|
return buf.ToString();
|
|
}
|
|
|
|
private static IEnumerable<SourceConstructFlags> GetFSharpFlags(Collection<CustomAttribute> customAttributes)
|
|
{
|
|
foreach (var attribute in customAttributes)
|
|
{
|
|
if (attribute.AttributeType.Name.Contains("CompilationMapping"))
|
|
{
|
|
var sourceConstructFlags = attribute.ConstructorArguments.Where(
|
|
i => i.Type.FullName == "Microsoft.FSharp.Core.SourceConstructFlags");
|
|
foreach (var customAttributeArgument in sourceConstructFlags)
|
|
{
|
|
var constructFlags = (SourceConstructFlags)customAttributeArgument.Value;
|
|
yield return constructFlags;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string GetGenericName(string name)
|
|
{
|
|
var trimmedName = name.TrimStart('T');
|
|
if (trimmedName.Length == 0 || !Regex.IsMatch(trimmedName, @"^[a-zA-Z]+$"))
|
|
trimmedName = name;
|
|
return $"\'{trimmedName}";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get sequencing of curried arguments
|
|
/// </summary>
|
|
/// <returns>Positions between arguments which are curried</returns>
|
|
protected HashSet<int> GetCurryBorders(MethodDefinition method)
|
|
{
|
|
var compilationArgumentCounts = GetCustomAttribute(method.CustomAttributes,
|
|
"CompilationArgumentCountsAttribute");
|
|
|
|
int[] curryCounts = { };
|
|
if (compilationArgumentCounts != null)
|
|
{
|
|
var customAttributeArguments =
|
|
(CustomAttributeArgument[])compilationArgumentCounts.ConstructorArguments[0].Value;
|
|
curryCounts = customAttributeArguments.Select(i => (int)i.Value).ToArray();
|
|
}
|
|
var curryBorders = new HashSet<int>();
|
|
int sum = 0;
|
|
foreach (var curryCount in curryCounts)
|
|
{
|
|
sum += curryCount;
|
|
curryBorders.Add(sum);
|
|
}
|
|
return curryBorders;
|
|
}
|
|
|
|
private CustomAttribute GetCustomAttribute(Collection<CustomAttribute> customAttributes, string name)
|
|
{
|
|
return customAttributes.SingleOrDefault(i => i.AttributeType.Name == name);
|
|
}
|
|
|
|
protected bool TryAppendOperatorName(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
if (!IsOperator(method))
|
|
return false;
|
|
if (operators.ContainsKey(method.Name))
|
|
{
|
|
buf.Append($"( {operators[method.Name]} )");
|
|
return true;
|
|
}
|
|
|
|
if (TryAppendCombinatedOperandName(buf, method))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TryAppendCombinatedOperandName(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
var oldName = method.Name.Remove(0, 3);
|
|
var newName = new StringBuilder();
|
|
bool found;
|
|
do
|
|
{
|
|
found = false;
|
|
foreach (var op in combinatedOperators)
|
|
{
|
|
if (oldName.StartsWith(op.Key))
|
|
{
|
|
oldName = oldName.Remove(0, op.Key.Length);
|
|
newName.Append(op.Value);
|
|
found = true;
|
|
}
|
|
}
|
|
} while (found);
|
|
|
|
if (oldName.Length == 0)
|
|
{
|
|
buf.Append($"( {newName} )");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected override StringBuilder AppendPointerTypeName(StringBuilder buf, TypeReference type, DynamicParserContext context)
|
|
{
|
|
TypeSpecification spec = type as TypeSpecification;
|
|
buf.Append("nativeptr<");
|
|
_AppendTypeName(buf, spec != null ? spec.ElementType : type.GetElementType(), context);
|
|
buf.Append(">");
|
|
return buf;
|
|
}
|
|
|
|
#region "Is" methods
|
|
private static bool IsOperator(MethodDefinition method)
|
|
{
|
|
return method.Name.StartsWith("op_", StringComparison.Ordinal);
|
|
}
|
|
|
|
private static bool IsFSharpFunction(TypeReference type)
|
|
{
|
|
return type.FullName.StartsWith("Microsoft.FSharp.Core.FSharpFunc`");
|
|
}
|
|
|
|
private static bool IsTuple(TypeReference type)
|
|
{
|
|
return type.FullName.StartsWith("System.Tuple");
|
|
}
|
|
|
|
private bool IsFlexibleType(GenericParameter genericParameter)
|
|
{
|
|
#if NEW_CECIL
|
|
return genericParameter.Constraints.Count == 1 && GetFSharpType(genericParameter.Constraints[0].ConstraintType.GetElementType()) != null;
|
|
#else
|
|
return genericParameter.Constraints.Count == 1 && GetFSharpType(genericParameter.Constraints[0].GetElementType()) != null;
|
|
#endif
|
|
}
|
|
|
|
private static bool IsModule(TypeDefinition type)
|
|
{
|
|
var fSharpFlags = GetFSharpFlags(type.CustomAttributes);
|
|
return fSharpFlags.Any(i => i == SourceConstructFlags.Module);
|
|
}
|
|
|
|
private static bool IsDiscriminatedUnion(TypeDefinition type)
|
|
{
|
|
var fSharpFlags = GetFSharpFlags(type.CustomAttributes);
|
|
return fSharpFlags.Any(i => i == SourceConstructFlags.SumType);
|
|
}
|
|
|
|
private static bool IsDiscriminatedUnionCase(TypeDefinition type)
|
|
{
|
|
return type.DeclaringType != null && IsDiscriminatedUnion(type.DeclaringType);
|
|
}
|
|
|
|
private static bool IsRecord(TypeDefinition type)
|
|
{
|
|
var fSharpFlags = GetFSharpFlags(type.CustomAttributes);
|
|
return fSharpFlags.Any(i => i == SourceConstructFlags.RecordType);
|
|
}
|
|
|
|
protected static bool IsExtensionMethod(MethodDefinition method)
|
|
{
|
|
var firstParameter = method.Parameters.FirstOrDefault();
|
|
return firstParameter != null && firstParameter.Name == "this";
|
|
}
|
|
#endregion
|
|
|
|
#region Visibility
|
|
protected override StringBuilder AppendVisibility(StringBuilder buf, MethodDefinition method)
|
|
{
|
|
if (method.IsPublic
|
|
|| method.IsFamily
|
|
|| method.IsFamilyOrAssembly)
|
|
return buf.Append("");
|
|
return null;
|
|
}
|
|
|
|
private static string GetTypeVisibility(TypeAttributes ta)
|
|
{
|
|
switch (ta & TypeAttributes.VisibilityMask)
|
|
{
|
|
case TypeAttributes.Public:
|
|
case TypeAttributes.NestedPublic:
|
|
return "";
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static string GetFieldVisibility(FieldDefinition field)
|
|
{
|
|
if (field.IsPublic
|
|
|| field.IsFamily
|
|
|| field.IsFamilyOrAssembly)
|
|
{
|
|
return "";
|
|
}
|
|
return null;
|
|
}
|
|
#endregion
|
|
|
|
#region Supported
|
|
public override bool IsSupported(TypeReference tref)
|
|
{
|
|
if (tref.DeclaringType != null
|
|
&& IsDiscriminatedUnion(tref.DeclaringType.Resolve())
|
|
&& tref.Name == "Tags")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool IsSupported(MemberReference mref)
|
|
{
|
|
if (mref.DeclaringType != null && IsDiscriminatedUnion(mref.DeclaringType.Resolve()))
|
|
{
|
|
var property = mref as PropertyDefinition;
|
|
if (property?.GetMethod != null)
|
|
{
|
|
var fSharpFlags = GetFSharpFlags(property.GetMethod.CustomAttributes);
|
|
if (fSharpFlags.Any(i => i == SourceConstructFlags.UnionCase))// For descriminated unions show only properties with UnionCase attribute
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
switch (mref)
|
|
{
|
|
case MethodDefinition method:
|
|
return !(method.HasCustomAttributes && method.CustomAttributes.Any(
|
|
ca => ca.GetDeclaringType() ==
|
|
"System.Diagnostics.Contracts.ContractInvariantMethodAttribute"
|
|
|| ca.GetDeclaringType() ==
|
|
Consts.CompilerGeneratedAttribute))
|
|
&& AppendVisibility(new StringBuilder(), method) != null;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region Private types
|
|
// Copied from F# Core
|
|
private enum SourceConstructFlags
|
|
{
|
|
/// <summary>Indicates that the compiled entity has no relationship to an element in F# source code.</summary>
|
|
None,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# union type declaration.</summary>
|
|
SumType,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# record type declaration.</summary>
|
|
RecordType,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# class or other object type declaration.</summary>
|
|
ObjectType,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# record or union case field declaration.</summary>
|
|
Field,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# exception declaration.</summary>
|
|
Exception,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# closure.</summary>
|
|
Closure,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# module declaration.</summary>
|
|
Module,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# union case declaration.</summary>
|
|
UnionCase,
|
|
/// <summary>Indicates that the compiled entity is part of the representation of an F# value declaration.</summary>
|
|
Value,
|
|
/// <summary>The mask of values related to the kind of the compiled entity.</summary>
|
|
KindMask = 31,
|
|
/// <summary>Indicates that the compiled entity had private or internal representation in F# source code.</summary>
|
|
NonPublicRepresentation
|
|
}
|
|
|
|
private enum GenericParameterState
|
|
{
|
|
None,
|
|
WithinTuple
|
|
}
|
|
|
|
private enum FSharpMethodKind
|
|
{
|
|
InModule,
|
|
Static,
|
|
Override,
|
|
Abstract,
|
|
Virtual,
|
|
Common,
|
|
}
|
|
#endregion
|
|
}
|
|
}
|