diff options
261 files changed, 24711 insertions, 162 deletions
@@ -55,7 +55,7 @@ apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BF echo "deb http://download.mono-project.com/repo/ubuntu trusty main" | tee /etc/apt/sources.list.d/mono-official.list apt-get update -apt-get install git make mono-devel ca-certificates-mono wget nuget -y +apt-get install git make mono-devel ca-certificates-mono wget nuget fsharp -y wget -q 'http://mxr.mozilla.org/seamonkey/source/security/nss/lib/ckfw/builtins/certdata.txt?raw=1' -O "/tmp/certdata.txt" mozroots --import --ask-remove --file /tmp/certdata.txt diff --git a/apidoctools.sln b/apidoctools.sln index 5198b261..9f53f496 100644 --- a/apidoctools.sln +++ b/apidoctools.sln @@ -1,7 +1,7 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
-VisualStudioVersion = 15.0.26206.0
+VisualStudioVersion = 15.0.26730.16
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "mdoc", "mdoc\mdoc.csproj", "{7DA7CD97-614F-4BCD-A2FA-B379590CEA48}"
EndProject
@@ -13,6 +13,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpZipLib", " EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "mdoc.Test", "mdoc\mdoc.Test\mdoc.Test.csproj", "{5ADDEFB6-930C-46BC-8B2B-FDE5C7E3B5AD}"
EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "mdoc.Test.FSharp", "mdoc\mdoc.Test\mdoc.Test.FSharp\mdoc.Test.FSharp.fsproj", "{979F9F80-12FE-4236-9E93-6D554AB13701}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -61,10 +63,21 @@ Global {5ADDEFB6-930C-46BC-8B2B-FDE5C7E3B5AD}.Release|Any CPU.Build.0 = Release|Any CPU
{5ADDEFB6-930C-46BC-8B2B-FDE5C7E3B5AD}.Release|x86.ActiveCfg = Release|Any CPU
{5ADDEFB6-930C-46BC-8B2B-FDE5C7E3B5AD}.Release|x86.Build.0 = Release|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Debug|x86.Build.0 = Debug|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Release|Any CPU.Build.0 = Release|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Release|x86.ActiveCfg = Release|Any CPU
+ {979F9F80-12FE-4236-9E93-6D554AB13701}.Release|x86.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {E2C93D4B-019B-42E1-AFC1-D7B9A47D8D33}
+ EndGlobalSection
GlobalSection(MonoDevelopProperties) = preSolution
StartupItem = mdoc.csproj
EndGlobalSection
diff --git a/mdoc/Consts.cs b/mdoc/Consts.cs index 3eeb2ca9..6137698a 100644 --- a/mdoc/Consts.cs +++ b/mdoc/Consts.cs @@ -8,5 +8,8 @@ namespace Mono.Documentation public const string VbNet = "VB.NET"; public const string DocIdLowCase = "docid"; public const string VbNetLowCase = "vb.net"; + public const string FSharp = "F#"; + public const string FSharpLowCase = "f#"; + public const string Tab = " "; } } diff --git a/mdoc/Makefile b/mdoc/Makefile index f41a5f16..aae603b4 100644 --- a/mdoc/Makefile +++ b/mdoc/Makefile @@ -424,6 +424,13 @@ check-monodocer-fx-statistics-remove: cp Test/DocTest-DropNS-unified.dll Test/fx-import/one/DocTest.dll $(MONO) $(PROGRAM) update -o Test/en.actual -frameworks Test/fx-import -statistics Test/actual_statistics.txt $(DIFF) Test/expected_fx_remove_statistics.txt Test/actual_statistics.txt + +check-monodocer-fsharp: + -rm -Rf Test/en.actual + msbuild ../mdoc/mdoc.Test/mdoc.Test.FSharp/mdoc.Test.FSharp.fsproj -property:Configuration=Release + $(MONO) $(PROGRAM) update -lang fsharp -o Test/en.actual ../mdoc/mdoc.Test/mdoc.Test.FSharp/bin/Release/mdoc.Test.FSharp.dll + $(DIFF) Test/en.expected-fsharp Test/en.actual + .PHONY: check-monodocer-import-fx check-monodocer-import-fx: check-monodocer-import-fx-work @@ -559,6 +566,7 @@ check-doc-tools: check-monodocer-since \ check-monodocer-vbnet \ check-monodocer-vbnet2 \ check-monodocer-frameworks-with-nuget\ + check-monodocer-fsharp \ check-doc-tools-update: check-monodocer-since-update \ diff --git a/mdoc/Mono.Documentation/MDocUpdater.cs b/mdoc/Mono.Documentation/MDocUpdater.cs index 13fc7423..f18541ae 100644 --- a/mdoc/Mono.Documentation/MDocUpdater.cs +++ b/mdoc/Mono.Documentation/MDocUpdater.cs @@ -211,7 +211,7 @@ namespace Mono.Documentation v => { AddFormatter(Consts.DocId); - } },
+ } }, { "lang=", "Add languages to the list of type and member signatures (DocId, VB.NET). Values can be coma separated", v => @@ -391,17 +391,22 @@ namespace Mono.Documentation MemberFormatter typeFormatter; langId = langId.ToLower(); switch (langId) - {
- case Consts.DocIdLowCase:
- typeFormatter = new DocIdFormatter();
- memberFormatter = new DocIdFormatter();
- break;
- case Consts.VbNetLowCase:
- typeFormatter = new VBMemberFormatter();
- memberFormatter = new VBMemberFormatter();
- break;
- default:
- throw new ArgumentException("Unsupported formatter id '" + langId + "'.");
+ { + case Consts.DocIdLowCase: + typeFormatter = new DocIdFormatter(); + memberFormatter = new DocIdFormatter(); + break; + case Consts.VbNetLowCase: + typeFormatter = new VBMemberFormatter(); + memberFormatter = new VBMemberFormatter(); + break; + case Consts.FSharpLowCase: + case "fsharp": + typeFormatter = new FSharpMemberFormatter(); + memberFormatter = new FSharpFullMemberFormatter(); + break; + default: + throw new ArgumentException("Unsupported formatter id '" + langId + "'."); } typeFormatters = typeFormatters.Union(new[] { typeFormatter }).ToArray(); memberFormatters = memberFormatters.Union(new[] { memberFormatter }).ToArray(); @@ -921,7 +926,7 @@ namespace Mono.Documentation // Add namespace and type nodes into the index file as needed string ns = DocUtils.GetNamespace (type); - XmlElement nsnode = (XmlElement)index_types.SelectSingleNode ("Namespace[@Name='" + ns + "']"); + XmlElement nsnode = (XmlElement)index_types.SelectSingleNode ("Namespace[@Name=" + DocUtils.GetStringForXPath(ns) + "]"); if (nsnode == null) { nsnode = index_types.OwnerDocument.CreateElement ("Namespace"); @@ -929,7 +934,7 @@ namespace Mono.Documentation index_types.AppendChild (nsnode); } string doc_typename = GetDocTypeName (type); - XmlElement typenode = (XmlElement)nsnode.SelectSingleNode ("Type[@Name='" + typename + "']"); + XmlElement typenode = (XmlElement)nsnode.SelectSingleNode ("Type[@Name=" + DocUtils.GetStringForXPath(typename) + "]"); if (typenode == null) { typenode = index_types.OwnerDocument.CreateElement ("Type"); @@ -2080,8 +2085,13 @@ namespace Mono.Documentation () => { var node = WriteElementAttribute (me, element, "Language", f.Language, forceNewElement: true); - var newNode = WriteElementAttribute (me, node, "Value", valueToUse); - return newNode; + node = WriteElementAttribute (me, node, "Value", valueToUse); + var usageSample = f.UsageFormatter?.GetDeclaration(mi); + if (usageSample != null) + { + node = WriteElementAttribute(me, node, "Usage", usageSample); + } + return node; }, mi); } @@ -2910,6 +2920,8 @@ namespace Mono.Documentation "System.Runtime.CompilerServices.ExtensionAttribute", // Used to differentiate 'object' from C#4 'dynamic' "System.Runtime.CompilerServices.DynamicAttribute", + // F# compiler attribute + "Microsoft.FSharp.Core.CompilationMapping", }; private IEnumerable<char> FilterSpecialChars (string value) @@ -3233,12 +3245,8 @@ namespace Mono.Documentation string sigs = memberFormatters[0].GetDeclaration (mi); if (sigs == null) return null; // not publicly visible - // no documentation for property/event accessors. Is there a better way of doing this? - if (mi.Name.StartsWith ("get_", StringComparison.Ordinal)) return null; - if (mi.Name.StartsWith ("set_", StringComparison.Ordinal)) return null; - if (mi.Name.StartsWith ("add_", StringComparison.Ordinal)) return null; - if (mi.Name.StartsWith ("remove_", StringComparison.Ordinal)) return null; - if (mi.Name.StartsWith ("raise_", StringComparison.Ordinal)) return null; + if (DocUtils.IsIgnored(mi)) + return null; XmlElement me = doc.CreateElement ("Member"); members.AppendChild (me); diff --git a/mdoc/Mono.Documentation/Updater/DocUtils.cs b/mdoc/Mono.Documentation/Updater/DocUtils.cs index 32ae5e3b..b31f6851 100644 --- a/mdoc/Mono.Documentation/Updater/DocUtils.cs +++ b/mdoc/Mono.Documentation/Updater/DocUtils.cs @@ -294,35 +294,68 @@ namespace Mono.Documentation.Updater return inheritedInterfaces;
}
- public static void AppendFieldValue(StringBuilder buf, FieldDefinition field) - { - // enums have a value__ field, which we ignore - if (((TypeDefinition)field.DeclaringType).IsEnum || - field.DeclaringType.IsGenericType()) - return; - if (field.HasConstant && field.IsLiteral) - { - object val = null; - try - { - val = field.Constant; - } - catch - { - return; - } - if (val == null) - buf.Append(" = ").Append("null"); - else if (val is Enum) - buf.Append(" = ").Append(val.ToString()); - else if (val is IFormattable) - { - string value = ((IFormattable)val).ToString(null, CultureInfo.InvariantCulture); - if (val is string) - value = "\"" + value + "\""; - buf.Append(" = ").Append(value); - } - } + public static void AppendFieldValue(StringBuilder buf, FieldDefinition field)
+ {
+ // enums have a value__ field, which we ignore
+ if (((TypeDefinition)field.DeclaringType).IsEnum ||
+ field.DeclaringType.IsGenericType())
+ return;
+ if (field.HasConstant && field.IsLiteral)
+ {
+ object val = null;
+ try
+ {
+ val = field.Constant;
+ }
+ catch
+ {
+ return;
+ }
+ if (val == null)
+ buf.Append(" = ").Append("null");
+ else if (val is Enum)
+ buf.Append(" = ").Append(val.ToString());
+ else if (val is IFormattable)
+ {
+ string value = ((IFormattable)val).ToString(null, CultureInfo.InvariantCulture);
+ if (val is string)
+ value = "\"" + value + "\"";
+ buf.Append(" = ").Append(value);
+ }
+ }
+ }
+
+ /// <summary>
+ /// XPath is invalid if it containt '-symbol inside '...'.
+ /// So, put string which contains '-symbol inside "...", and vice versa
+ /// </summary>
+ public static string GetStringForXPath(string input)
+ {
+ if (!input.Contains("'"))
+ return $"\'{input}\'";
+ if (!input.Contains("\""))
+ return $"\"{input}\"";
+ return input;
+ }
+
+ /// <summary>
+ /// No documentation for property/event accessors.
+ /// </summary>
+ public static bool IsIgnored(MemberReference mi)
+ {
+ if (mi.Name.StartsWith("get_", StringComparison.Ordinal)) return true;
+ if (mi.Name.StartsWith("set_", StringComparison.Ordinal)) return true;
+ if (mi.Name.StartsWith("add_", StringComparison.Ordinal)) return true;
+ if (mi.Name.StartsWith("remove_", StringComparison.Ordinal)) return true;
+ if (mi.Name.StartsWith("raise_", StringComparison.Ordinal)) return true;
+ return false;
+ }
+
+ public static bool IsAvailablePropertyMethod(MethodDefinition method)
+ {
+ return method != null
+ && (IsExplicitlyImplemented(method)
+ || (!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly));
}
}
}
\ No newline at end of file diff --git a/mdoc/Mono.Documentation/Updater/DocumentationEnumerator.cs b/mdoc/Mono.Documentation/Updater/DocumentationEnumerator.cs index 53d5e8b0..d5f35fc7 100644 --- a/mdoc/Mono.Documentation/Updater/DocumentationEnumerator.cs +++ b/mdoc/Mono.Documentation/Updater/DocumentationEnumerator.cs @@ -27,8 +27,6 @@ namespace Mono.Documentation.Updater if (seen != null && seen.Contains (type.FullName)) continue; yield return type; - foreach (TypeDefinition nested in type.NestedTypes) - yield return nested; } } diff --git a/mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs index f7421c4b..314c8e16 100644 --- a/mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs +++ b/mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs @@ -7,9 +7,9 @@ using System.Text; using Mono.Cecil; using Mono.Documentation.Util; -
+ namespace Mono.Documentation.Updater -{
+{ public class CSharpFullMemberFormatter : MemberFormatter { diff --git a/mdoc/Mono.Documentation/Updater/Formatters/FSharpFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/FSharpFormatter.cs new file mode 100644 index 00000000..e4709191 --- /dev/null +++ b/mdoc/Mono.Documentation/Updater/Formatters/FSharpFormatter.cs @@ -0,0 +1,1056 @@ +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) + { + if (type.IsValueType + && ignoredValueTypeInterfaces.Any(i => interfaceImplementation.InterfaceType.FullName.StartsWith(i))) + 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) + { + 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); + 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 + _AppendTypeName(buf, genericParameter.Constraints[0], context); + } + else + { + _AppendTypeName(buf, genArg, context); + } + } + MemberFormatterState = origState; + genericParameterState = genericParameterStateOrigState; + + if (MemberFormatterState == MemberFormatterState.None) + { + AppendConstraints(buf, + genArgs.GetRange(0, notYetDisplayedArguments) + .Where(i => i is GenericParameter) + .Cast<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) + { + List<string> constraintStrings = new List<string>(); + + foreach (GenericParameter genArg in genArgs.Where(i => !IsFlexibleType(i))) + { + GenericParameterAttributes attrs = genArg.Attributes; + IList<TypeReference> constraints = genArg.Constraints; + 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) + { + constraintStrings.Add($"{genericName} :> {GetTypeName(typeReference)}"); + } + } + if (isnew && !isvt) + { + constraintStrings.Add($"{genericName} : (new : unit -> {GetTypeName(genArg)})"); + } + } + + if (constraintStrings.Count > 0) + { + buf.Append($" (requires {string.Join(" and ", constraintStrings)})"); + } + } + + 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) + { + if (method.HasCustomAttributes && method.CustomAttributes.Any( + ca => ca.GetDeclaringType() == "System.Diagnostics.Contracts.ContractInvariantMethodAttribute" + || ca.GetDeclaringType() == "System.Runtime.CompilerServices.CompilerGeneratedAttribute")) + return null; + + 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.BaseType == null) + return false; + var baseType = type.BaseType.Resolve(); + if (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(property.Name); + 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) + { + return genericParameter.Constraints.Count == 1 && GetFSharpType(genericParameter.Constraints[0].GetElementType()) != null; + } + + 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; + } + 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 + } +}
\ No newline at end of file diff --git a/mdoc/Mono.Documentation/Updater/Formatters/FSharpFullMemberFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/FSharpFullMemberFormatter.cs new file mode 100644 index 00000000..e4d4f10c --- /dev/null +++ b/mdoc/Mono.Documentation/Updater/Formatters/FSharpFullMemberFormatter.cs @@ -0,0 +1,21 @@ +using System.Text; +using Mono.Cecil; + +namespace Mono.Documentation.Updater +{ + public class FSharpFullMemberFormatter : FSharpFormatter + { + public override string Language => Consts.FSharp; + + private readonly MemberFormatter usageFormatter = new FSharpUsageFormatter(); + public override MemberFormatter UsageFormatter => usageFormatter; + + protected override StringBuilder AppendNamespace(StringBuilder buf, TypeReference type) + { + string ns = DocUtils.GetNamespace(type); + if (GetFSharpType(type) == null && !string.IsNullOrEmpty(ns) && ns != "System") + buf.Append(ns).Append('.'); + return buf; + } + } +} diff --git a/mdoc/Mono.Documentation/Updater/Formatters/FSharpMemberFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/FSharpMemberFormatter.cs new file mode 100644 index 00000000..540c34b4 --- /dev/null +++ b/mdoc/Mono.Documentation/Updater/Formatters/FSharpMemberFormatter.cs @@ -0,0 +1,13 @@ +using System.Text; +using Mono.Cecil; + +namespace Mono.Documentation.Updater +{ + public class FSharpMemberFormatter : FSharpFullMemberFormatter + { + protected override StringBuilder AppendNamespace(StringBuilder buf, TypeReference type) + { + return buf; + } + } +}
\ No newline at end of file diff --git a/mdoc/Mono.Documentation/Updater/Formatters/FSharpUsageFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/FSharpUsageFormatter.cs new file mode 100644 index 00000000..3bc076b0 --- /dev/null +++ b/mdoc/Mono.Documentation/Updater/Formatters/FSharpUsageFormatter.cs @@ -0,0 +1,176 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Mono.Cecil; + +namespace Mono.Documentation.Updater +{ + public class FSharpUsageFormatter : FSharpFormatter + { + private static readonly Dictionary<string, string> operatorsUsage = new Dictionary<string, string>() + { + {"~-", "-"}, + {"~+", "+"}, + }; + + protected override string GetMethodDeclaration(MethodDefinition method) + { + var buf = new StringBuilder(); + var operatorBuf = new StringBuilder(); + if (TryAppendOperatorName(operatorBuf, method)) + { + return GetOperatorUsage(buf, method, operatorBuf.ToString()); + } + + if (method.IsStatic) + { + buf.Append($"{GetName(method.DeclaringType)}.{method.Name} "); + } + else + { + var typeName = AppendTypeName(new StringBuilder(), method.DeclaringType, null).ToString(); + buf.Append($"{CamelCase(typeName)}.{method.Name} "); + } + + AppendParameters(buf, method); + return buf.ToString(); + } + + private void AppendParameters(StringBuilder buf, MethodDefinition method) + { + var parameters = new List<string>(); + var curryBorders = GetCurryBorders(method); + bool isExtensionMethod = IsExtensionMethod(method); + for (var i = 0; i < method.Parameters.Count; i++) + { + if (isExtensionMethod && i == 0) + continue; + if (curryBorders.Contains(i) && parameters.Count > 0) + { + AppendTupleUsage(buf, parameters); + parameters.Clear(); + buf.Append(" "); + } + var parameterDefinition = method.Parameters[i]; + parameters.Add(GetParameterUsage(parameterDefinition)); + } + AppendTupleUsage(buf, parameters); + } + + private string GetOperatorUsage(StringBuilder buf, MethodDefinition method, string operatorName) + { + var operatorMembers = operatorName.Split(' ').Skip(1).ToList(); + operatorMembers = operatorMembers.Take(operatorMembers.Count - 1).ToList();// Remove '(' and ')' + for (var i = 0; i < operatorMembers.Count; i++) + { + if (operatorsUsage.ContainsKey(operatorMembers[i])) + { + operatorMembers[i] = operatorsUsage[operatorMembers[i]]; + } + } + + var curryBorders = GetCurryBorders(method); + var parameters = new List<string>(); + + if (curryBorders.Count > 0) + {// if parameters are curried + int operatorIndex = 0; + for (var i = 0; i < method.Parameters.Count; i++) + { + if (curryBorders.Contains(i)) + { + AppendTupleUsage(buf, parameters); + parameters.Clear(); + buf.Append(" "); + if (operatorIndex < operatorMembers.Count) + { + buf.Append(operatorMembers[operatorIndex]); + ++operatorIndex; + } + buf.Append(" "); + } + var parameterDefinition = method.Parameters[i]; + parameters.Add(GetParameterUsage(parameterDefinition)); + } + AppendTupleUsage(buf, parameters); + } + else + { + var members = new List<string>(); + for (var i = 0; i < method.Parameters.Count; i++) + { + if (method.Parameters.Count <= operatorMembers.Count) + { + if (i < operatorMembers.Count) + { + members.Add(operatorMembers[i]); + } + } + + var parameterDefinition = method.Parameters[i]; + members.Add(GetParameterUsage(parameterDefinition)); + + if (method.Parameters.Count > operatorMembers.Count) + { + if (i < operatorMembers.Count) + { + members.Add(operatorMembers[i]); + } + } + } + buf.Append(string.Join(" ", members)); + } + return buf.ToString(); + } + + private static string CamelCase(string name) + { + return Char.ToLowerInvariant(name[0]) + name.Substring(1); + } + + private void AppendTupleUsage(StringBuilder buf, List<string> parameters) + { + if (parameters.Count == 0) + return; + + if (parameters.Count == 1) + { + buf.Append(parameters[0]); + return; + } + buf.Append($"({string.Join(", ", parameters)})"); + } + + private string GetParameterUsage(ParameterDefinition parameterDefinition) + { + return parameterDefinition.Name; + } + + protected override string GetPropertyDeclaration(PropertyDefinition property) + { + return $"{GetName(property.DeclaringType)}.{property.Name}"; + } + + 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(" "); + AppendParameters(buf, constructor); + return buf.ToString(); + } + + protected override string GetFieldDeclaration(FieldDefinition field) + { + return $"{GetName(field.DeclaringType)}.{field.Name}"; + } + } +}
\ No newline at end of file diff --git a/mdoc/Mono.Documentation/Updater/Formatters/MemberFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/MemberFormatter.cs index 5a959a10..c97397e7 100644 --- a/mdoc/Mono.Documentation/Updater/Formatters/MemberFormatter.cs +++ b/mdoc/Mono.Documentation/Updater/Formatters/MemberFormatter.cs @@ -441,5 +441,12 @@ namespace Mono.Documentation.Updater return isPublicEII; } + + public virtual MemberFormatter UsageFormatter { get; protected set; } + + public static string GetLineEnding() + { + return "\n"; + } } }
\ No newline at end of file diff --git a/mdoc/Mono.Documentation/Updater/Formatters/VBFullMemberFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/VBFullMemberFormatter.cs index 03b06c98..d3560fa4 100644 --- a/mdoc/Mono.Documentation/Updater/Formatters/VBFullMemberFormatter.cs +++ b/mdoc/Mono.Documentation/Updater/Formatters/VBFullMemberFormatter.cs @@ -571,23 +571,16 @@ namespace Mono.Documentation.Updater protected override string GetPropertyDeclaration(PropertyDefinition property) { - MethodDefinition method; - string getVisible = null; - if ((method = property.GetMethod) != null && - (DocUtils.IsExplicitlyImplemented(method) || - (!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly))) - getVisible = AppendVisibility(new StringBuilder(), method).ToString(); + if (DocUtils.IsAvailablePropertyMethod(property.GetMethod)) + getVisible = AppendVisibility(new StringBuilder(), property.GetMethod).ToString(); string setVisible = null; - if ((method = property.SetMethod) != null && - (DocUtils.IsExplicitlyImplemented(method) || - (!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly))) - setVisible = AppendVisibility(new StringBuilder(), method).ToString(); + if (DocUtils.IsAvailablePropertyMethod(property.SetMethod)) + setVisible = AppendVisibility(new StringBuilder(), property.SetMethod).ToString(); - if ((setVisible == null) && (getVisible == null)) + if (setVisible == null && getVisible == null) return null; - string visibility; StringBuilder buf = new StringBuilder(); IEnumerable<MemberReference> defs = property.DeclaringType.GetDefaultMembers(); bool indexer = false; @@ -602,14 +595,14 @@ namespace Mono.Documentation.Updater if (indexer) buf.Append("Default "); if (getVisible != null && (setVisible == null || (setVisible != null && getVisible == setVisible))) - buf.Append(visibility = getVisible); + buf.Append(getVisible); else if (setVisible != null && getVisible == null) - buf.Append(visibility = setVisible); + buf.Append(setVisible); else - buf.Append(visibility = "Public"); + buf.Append("Public"); // Pick an accessor to use for static/virtual/override/etc. checks. - method = property.SetMethod; + var method = property.SetMethod; if (method == null) method = property.GetMethod; @@ -851,10 +844,5 @@ namespace Mono.Documentation.Updater { return method.Name.StartsWith("op_", StringComparison.Ordinal); } - - private static string GetLineEnding() - { - return "\n"; - } } } diff --git a/mdoc/Test/en.expected-fsharp/AbstractClasses+Circle.xml b/mdoc/Test/en.expected-fsharp/AbstractClasses+Circle.xml new file mode 100644 index 00000000..7de89bed --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/AbstractClasses+Circle.xml @@ -0,0 +1,119 @@ +<Type Name="AbstractClasses+Circle" FullName="AbstractClasses+Circle"> + <TypeSignature Language="C#" Value="public class AbstractClasses.Circle : AbstractClasses.Shape2D" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable AbstractClasses/Circle extends ctClasses/Shape2D" /> + <TypeSignature Language="F#" Value="type AbstractClasses.Circle = class
 inherit AbstractClasses.Shape2D" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>AbstractClasses+Shape2D</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Circle (double x, double y, double radius);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y, float64 radius) cil managed" /> + <MemberSignature Language="F#" Value="new AbstractClasses.Circle : double * double * double -> AbstractClasses.Circle" Usage="new AbstractClasses.Circle (x, y, radius)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + <Parameter Name="radius" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="radius">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Area"> + <MemberSignature Language="C#" Value="public override double Area { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Area" /> + <MemberSignature Language="F#" Value="member this.Area : double" Usage="AbstractClasses.Circle.Area" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Radius"> + <MemberSignature Language="C#" Value="public double Radius { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Radius" /> + <MemberSignature Language="F#" Value="member this.Radius : double" Usage="AbstractClasses.Circle.Radius" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate"> + <MemberSignature Language="C#" Value="public override void Rotate (double _arg1);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate(float64 _arg1) cil managed" /> + <MemberSignature Language="F#" Value="override this.Rotate : double -> unit" Usage="circle.Rotate _arg1" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_arg1" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_arg1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate2"> + <MemberSignature Language="C#" Value="public override void Rotate2 (double angle);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate2(float64 angle) cil managed" /> + <MemberSignature Language="F#" Value="override this.Rotate2 : double -> unit" Usage="circle.Rotate2 angle" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="angle" Type="System.Double" /> + </Parameters> + <Docs> + <param name="angle">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/AbstractClasses+Shape2D.xml b/mdoc/Test/en.expected-fsharp/AbstractClasses+Shape2D.xml new file mode 100644 index 00000000..79de697a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/AbstractClasses+Shape2D.xml @@ -0,0 +1,164 @@ +<Type Name="AbstractClasses+Shape2D" FullName="AbstractClasses+Shape2D"> + <TypeSignature Language="C#" Value="public abstract class AbstractClasses.Shape2D" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract serializable AbstractClasses/Shape2D extends System.Object" /> + <TypeSignature Language="F#" Value="type AbstractClasses.Shape2D = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.AbstractClass</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Shape2D (double x0, double y0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x0, float64 y0) cil managed" /> + <MemberSignature Language="F#" Value="new AbstractClasses.Shape2D : double * double -> AbstractClasses.Shape2D" Usage="new AbstractClasses.Shape2D (x0, y0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x0" Type="System.Double" /> + <Parameter Name="y0" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x0">To be added.</param> + <param name="y0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Area"> + <MemberSignature Language="C#" Value="public abstract double Area { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Area" /> + <MemberSignature Language="F#" Value="member this.Area : double" Usage="AbstractClasses.Shape2D.Area" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CenterX"> + <MemberSignature Language="C#" Value="public double CenterX { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 CenterX" /> + <MemberSignature Language="F#" Value="member this.CenterX : double with get, set" Usage="AbstractClasses.Shape2D.CenterX" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Move"> + <MemberSignature Language="C#" Value="public void Move (double dx, double dy);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Move(float64 dx, float64 dy) cil managed" /> + <MemberSignature Language="F#" Value="member this.Move : double -> double -> unit" Usage="shape2D.Move dx dy" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="dx" Type="System.Double" /> + <Parameter Name="dy" Type="System.Double" /> + </Parameters> + <Docs> + <param name="dx">To be added.</param> + <param name="dy">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate"> + <MemberSignature Language="C#" Value="public override void Rotate (double angle);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate(float64 angle) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Rotate : double -> unit
override this.Rotate : double -> unit" Usage="shape2D.Rotate angle" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="angle" Type="System.Double" /> + </Parameters> + <Docs> + <param name="angle">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate2"> + <MemberSignature Language="C#" Value="public abstract void Rotate2 (double );" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate2(float64 ) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Rotate2 : double -> unit" Usage="shape2D.Rotate2 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="" Type="System.Double" /> + </Parameters> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate3"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<double,Microsoft.FSharp.Core.Unit> Rotate3 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpFunc`2<float64, class Microsoft.FSharp.Core.Unit> Rotate3" /> + <MemberSignature Language="F#" Value="member this.Rotate3 : double -> unit" Usage="AbstractClasses.Shape2D.Rotate3" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Double,Microsoft.FSharp.Core.Unit></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/AbstractClasses+Square.xml b/mdoc/Test/en.expected-fsharp/AbstractClasses+Square.xml new file mode 100644 index 00000000..06e92757 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/AbstractClasses+Square.xml @@ -0,0 +1,99 @@ +<Type Name="AbstractClasses+Square" FullName="AbstractClasses+Square"> + <TypeSignature Language="C#" Value="public class AbstractClasses.Square : AbstractClasses.Shape2D" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable AbstractClasses/Square extends ctClasses/Shape2D" /> + <TypeSignature Language="F#" Value="type AbstractClasses.Square = class
 inherit AbstractClasses.Shape2D" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>AbstractClasses+Shape2D</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Square (double x, double y, double sideLengthIn);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y, float64 sideLengthIn) cil managed" /> + <MemberSignature Language="F#" Value="new AbstractClasses.Square : double * double * double -> AbstractClasses.Square" Usage="new AbstractClasses.Square (x, y, sideLengthIn)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + <Parameter Name="sideLengthIn" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="sideLengthIn">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Area"> + <MemberSignature Language="C#" Value="public override double Area { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Area" /> + <MemberSignature Language="F#" Value="member this.Area : double" Usage="AbstractClasses.Square.Area" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate2"> + <MemberSignature Language="C#" Value="public override void Rotate2 (double angle);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate2(float64 angle) cil managed" /> + <MemberSignature Language="F#" Value="override this.Rotate2 : double -> unit" Usage="square.Rotate2 angle" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="angle" Type="System.Double" /> + </Parameters> + <Docs> + <param name="angle">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SideLength"> + <MemberSignature Language="C#" Value="public double SideLength { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 SideLength" /> + <MemberSignature Language="F#" Value="member this.SideLength : double" Usage="AbstractClasses.Square.SideLength" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/AbstractClasses.xml b/mdoc/Test/en.expected-fsharp/AbstractClasses.xml new file mode 100644 index 00000000..6bf08911 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/AbstractClasses.xml @@ -0,0 +1,90 @@ +<Type Name="AbstractClasses" FullName="AbstractClasses"> + <TypeSignature Language="C#" Value="public static class AbstractClasses" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed AbstractClasses extends System.Object" /> + <TypeSignature Language="F#" Value="module AbstractClasses" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="circle1"> + <MemberSignature Language="C#" Value="public static AbstractClasses.Circle circle1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property AbstractClasses/Circle circle1" /> + <MemberSignature Language="F#" Value="AbstractClasses.circle1 : AbstractClasses.Circle" Usage="AbstractClasses.circle1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>AbstractClasses+Circle</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="shapeList"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Collections.FSharpList<AbstractClasses.Shape2D> shapeList { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Collections.FSharpList`1<AbstractClasses/Shape2D> shapeList" /> + <MemberSignature Language="F#" Value="AbstractClasses.shapeList : List<AbstractClasses.Shape2D>" Usage="AbstractClasses.shapeList" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Collections.FSharpList<AbstractClasses+Shape2D></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="square1"> + <MemberSignature Language="C#" Value="public static AbstractClasses.Square square1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property AbstractClasses/Square square1" /> + <MemberSignature Language="F#" Value="AbstractClasses.square1 : AbstractClasses.Square" Usage="AbstractClasses.square1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>AbstractClasses+Square</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Accessibility.xml b/mdoc/Test/en.expected-fsharp/Accessibility.xml new file mode 100644 index 00000000..e0a844d4 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Accessibility.xml @@ -0,0 +1,68 @@ +<Type Name="Accessibility" FullName="Accessibility"> + <TypeSignature Language="C#" Value="public static class Accessibility" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Accessibility extends System.Object" /> + <TypeSignature Language="F#" Value="module Accessibility" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="result1"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,int> result1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, int32> result1" /> + <MemberSignature Language="F#" Value="Accessibility.result1 : unit -> int" Usage="Accessibility.result1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="result2"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,int> result2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, int32> result2" /> + <MemberSignature Language="F#" Value="Accessibility.result2 : unit -> int" Usage="Accessibility.result2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/AccessibilityTest.xml b/mdoc/Test/en.expected-fsharp/AccessibilityTest.xml new file mode 100644 index 00000000..d3d56521 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/AccessibilityTest.xml @@ -0,0 +1,46 @@ +<Type Name="AccessibilityTest" FullName="AccessibilityTest"> + <TypeSignature Language="C#" Value="public static class AccessibilityTest" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed AccessibilityTest extends System.Object" /> + <TypeSignature Language="F#" Value="module AccessibilityTest" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="result"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,int> result { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, int32> result" /> + <MemberSignature Language="F#" Value="AccessibilityTest.result : unit -> int" Usage="AccessibilityTest.result" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/AlternativesToInheritance.xml b/mdoc/Test/en.expected-fsharp/AlternativesToInheritance.xml new file mode 100644 index 00000000..21d5900c --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/AlternativesToInheritance.xml @@ -0,0 +1,46 @@ +<Type Name="AlternativesToInheritance" FullName="AlternativesToInheritance"> + <TypeSignature Language="C#" Value="public static class AlternativesToInheritance" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed AlternativesToInheritance extends System.Object" /> + <TypeSignature Language="F#" Value="module AlternativesToInheritance" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="object1"> + <MemberSignature Language="C#" Value="public static object object1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property object object1" /> + <MemberSignature Language="F#" Value="AlternativesToInheritance.object1 : obj" Usage="AlternativesToInheritance.object1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Object</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Animals+Animal.xml b/mdoc/Test/en.expected-fsharp/Animals+Animal.xml new file mode 100644 index 00000000..6b3cca9e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Animals+Animal.xml @@ -0,0 +1,54 @@ +<Type Name="Animals+Animal" FullName="Animals+Animal"> + <TypeSignature Language="C#" Value="public class Animals.Animal" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Animals/Animal extends System.Object" /> + <TypeSignature Language="F#" Value="type Animals.Animal = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Animal ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rest"> + <MemberSignature Language="C#" Value="public void Rest ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Rest() cil managed" /> + <MemberSignature Language="F#" Value="member this.Rest : unit -> unit" Usage="animal.Rest " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Animals+Dog.xml b/mdoc/Test/en.expected-fsharp/Animals+Dog.xml new file mode 100644 index 00000000..04fd2500 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Animals+Dog.xml @@ -0,0 +1,54 @@ +<Type Name="Animals+Dog" FullName="Animals+Dog"> + <TypeSignature Language="C#" Value="public class Animals.Dog : Animals.Animal" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Animals/Dog extends s/Animal" /> + <TypeSignature Language="F#" Value="type Animals.Dog = class
 inherit Animals.Animal" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Animals+Animal</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Dog ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Run"> + <MemberSignature Language="C#" Value="public void Run ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Run() cil managed" /> + <MemberSignature Language="F#" Value="member this.Run : unit -> unit" Usage="dog.Run " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Animals.xml b/mdoc/Test/en.expected-fsharp/Animals.xml new file mode 100644 index 00000000..9f5d0c6f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Animals.xml @@ -0,0 +1,90 @@ +<Type Name="Animals" FullName="Animals"> + <TypeSignature Language="C#" Value="public static class Animals" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Animals extends System.Object" /> + <TypeSignature Language="F#" Value="module Animals" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="animal"> + <MemberSignature Language="C#" Value="public static Animals.Animal animal { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Animals/Animal animal" /> + <MemberSignature Language="F#" Value="Animals.animal : Animals.Animal" Usage="Animals.animal" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Animals+Animal</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="dog"> + <MemberSignature Language="C#" Value="public static Animals.Dog dog { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Animals/Dog dog" /> + <MemberSignature Language="F#" Value="Animals.dog : Animals.Dog" Usage="Animals.dog" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Animals+Dog</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="shouldBeADog"> + <MemberSignature Language="C#" Value="public static Animals.Dog shouldBeADog { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Animals/Dog shouldBeADog" /> + <MemberSignature Language="F#" Value="Animals.shouldBeADog : Animals.Dog" Usage="Animals.shouldBeADog" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Animals+Dog</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Attributes+CompanyAttribute.xml b/mdoc/Test/en.expected-fsharp/Attributes+CompanyAttribute.xml new file mode 100644 index 00000000..6fa56366 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Attributes+CompanyAttribute.xml @@ -0,0 +1,41 @@ +<Type Name="Attributes+CompanyAttribute" FullName="Attributes+CompanyAttribute"> + <TypeSignature Language="C#" Value="public class Attributes.CompanyAttribute : Attribute" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Attributes/CompanyAttribute extends System.Attribute" /> + <TypeSignature Language="F#" Value="type Attributes.CompanyAttribute = class
 inherit Attribute" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Attribute</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public CompanyAttribute (string name);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string name) cil managed" /> + <MemberSignature Language="F#" Value="new Attributes.CompanyAttribute : string -> Attributes.CompanyAttribute" Usage="new Attributes.CompanyAttribute name" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="name" Type="System.String" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Attributes+OwnerAttribute.xml b/mdoc/Test/en.expected-fsharp/Attributes+OwnerAttribute.xml new file mode 100644 index 00000000..f6bc5742 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Attributes+OwnerAttribute.xml @@ -0,0 +1,41 @@ +<Type Name="Attributes+OwnerAttribute" FullName="Attributes+OwnerAttribute"> + <TypeSignature Language="C#" Value="public class Attributes.OwnerAttribute : Attribute" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Attributes/OwnerAttribute extends System.Attribute" /> + <TypeSignature Language="F#" Value="type Attributes.OwnerAttribute = class
 inherit Attribute" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Attribute</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public OwnerAttribute (string name);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string name) cil managed" /> + <MemberSignature Language="F#" Value="new Attributes.OwnerAttribute : string -> Attributes.OwnerAttribute" Usage="new Attributes.OwnerAttribute name" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="name" Type="System.String" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Attributes+SomeType1.xml b/mdoc/Test/en.expected-fsharp/Attributes+SomeType1.xml new file mode 100644 index 00000000..9e50d4d3 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Attributes+SomeType1.xml @@ -0,0 +1,29 @@ +<Type Name="Attributes+SomeType1" FullName="Attributes+SomeType1"> + <TypeSignature Language="C#" Value="public class Attributes.SomeType1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Attributes/SomeType1 extends System.Object" /> + <TypeSignature Language="F#" Value="type Attributes.SomeType1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Attributes/Company("Microsoft")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Attributes/Owner("Jason Carlson")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Attributes+TypeWithFlagAttribute.xml b/mdoc/Test/en.expected-fsharp/Attributes+TypeWithFlagAttribute.xml new file mode 100644 index 00000000..7503f776 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Attributes+TypeWithFlagAttribute.xml @@ -0,0 +1,44 @@ +<Type Name="Attributes+TypeWithFlagAttribute" FullName="Attributes+TypeWithFlagAttribute"> + <TypeSignature Language="C#" Value="public class Attributes.TypeWithFlagAttribute" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Attributes/TypeWithFlagAttribute extends System.Object" /> + <TypeSignature Language="F#" Value="type Attributes.TypeWithFlagAttribute = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.AttributeUsage(System.AttributeTargets.Module | System.AttributeTargets.Event | System.AttributeTargets.Delegate, AllowMultiple=false)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public string X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string X" /> + <MemberSignature Language="F#" Value="member this.X : string" Usage="Attributes.TypeWithFlagAttribute.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Attributes.xml b/mdoc/Test/en.expected-fsharp/Attributes.xml new file mode 100644 index 00000000..56c7d410 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Attributes.xml @@ -0,0 +1,23 @@ +<Type Name="Attributes" FullName="Attributes"> + <TypeSignature Language="C#" Value="public static class Attributes" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Attributes extends System.Object" /> + <TypeSignature Language="F#" Value="module Attributes" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/ClassMembers+PointWithCounter.xml b/mdoc/Test/en.expected-fsharp/ClassMembers+PointWithCounter.xml new file mode 100644 index 00000000..85161c0e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ClassMembers+PointWithCounter.xml @@ -0,0 +1,111 @@ +<Type Name="ClassMembers+PointWithCounter" FullName="ClassMembers+PointWithCounter"> + <TypeSignature Language="C#" Value="public class ClassMembers.PointWithCounter" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable ClassMembers/PointWithCounter extends System.Object" /> + <TypeSignature Language="F#" Value="type ClassMembers.PointWithCounter = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public PointWithCounter (int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="new ClassMembers.PointWithCounter : int * int -> ClassMembers.PointWithCounter" Usage="new ClassMembers.PointWithCounter (a, b)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CreatedCount"> + <MemberSignature Language="C#" Value="public int CreatedCount { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 CreatedCount" /> + <MemberSignature Language="F#" Value="member this.CreatedCount : int" Usage="ClassMembers.PointWithCounter.CreatedCount" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="FunctionValue"> + <MemberSignature Language="C#" Value="public int FunctionValue { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 FunctionValue" /> + <MemberSignature Language="F#" Value="member this.FunctionValue : int" Usage="ClassMembers.PointWithCounter.FunctionValue" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Prop1"> + <MemberSignature Language="C#" Value="public int Prop1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Prop1" /> + <MemberSignature Language="F#" Value="member this.Prop1 : int" Usage="ClassMembers.PointWithCounter.Prop1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Prop2"> + <MemberSignature Language="C#" Value="public int Prop2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Prop2" /> + <MemberSignature Language="F#" Value="member this.Prop2 : int" Usage="ClassMembers.PointWithCounter.Prop2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/ClassMembers.xml b/mdoc/Test/en.expected-fsharp/ClassMembers.xml new file mode 100644 index 00000000..5228bff5 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ClassMembers.xml @@ -0,0 +1,46 @@ +<Type Name="ClassMembers" FullName="ClassMembers"> + <TypeSignature Language="C#" Value="public static class ClassMembers" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed ClassMembers extends System.Object" /> + <TypeSignature Language="F#" Value="module ClassMembers" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="point1"> + <MemberSignature Language="C#" Value="public static ClassMembers.PointWithCounter point1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property ClassMembers/PointWithCounter point1" /> + <MemberSignature Language="F#" Value="ClassMembers.point1 : ClassMembers.PointWithCounter" Usage="ClassMembers.point1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>ClassMembers+PointWithCounter</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Collections.xml b/mdoc/Test/en.expected-fsharp/Collections.xml new file mode 100644 index 00000000..a0028187 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Collections.xml @@ -0,0 +1,66 @@ +<Type Name="Collections" FullName="Collections"> + <TypeSignature Language="C#" Value="public static class Collections" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Collections extends System.Object" /> + <TypeSignature Language="F#" Value="module Collections" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="f"> + <MemberSignature Language="C#" Value="public static int f (Microsoft.FSharp.Collections.FSharpMap<int,int> x);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 f(class Microsoft.FSharp.Collections.FSharpMap`2<int32, int32> x) cil managed" /> + <MemberSignature Language="F#" Value="Collections.f : Map<int, int> -> int" Usage="Collections.f x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="Microsoft.FSharp.Collections.FSharpMap<System.Int32,System.Int32>" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="f2"> + <MemberSignature Language="C#" Value="public static int f2 (System.Collections.Generic.IEnumerable<int> x);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 f2(class System.Collections.Generic.IEnumerable`1<int32> x) cil managed" /> + <MemberSignature Language="F#" Value="Collections.f2 : seq<int> -> int" Usage="Collections.f2 x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Collections.Generic.IEnumerable<System.Int32>" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class10`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class10`1.xml new file mode 100644 index 00000000..a941803d --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class10`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class10<T>" FullName="Constraints+Class10<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class10<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class10`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class10<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class10 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class11`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class11`1.xml new file mode 100644 index 00000000..64bd7176 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class11`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class11<T>" FullName="Constraints+Class11<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class11<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class11`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class11<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class11 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class12`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class12`1.xml new file mode 100644 index 00000000..54217c60 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class12`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class12<T>" FullName="Constraints+Class12<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class12<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class12`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class12<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class12 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class13`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class13`1.xml new file mode 100644 index 00000000..0a616319 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class13`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class13<T>" FullName="Constraints+Class13<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class13<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class13`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class13<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class13 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class14`2.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class14`2.xml new file mode 100644 index 00000000..332c17c9 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class14`2.xml @@ -0,0 +1,43 @@ +<Type Name="Constraints+Class14<T,U>" FullName="Constraints+Class14<T,U>"> + <TypeSignature Language="C#" Value="public class Constraints.Class14<T,U>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class14`2<T, U> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class14<'T, 'U> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + <TypeParameter Name="U" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <typeparam name="U">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class14 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class15.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class15.xml new file mode 100644 index 00000000..9f210eeb --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class15.xml @@ -0,0 +1,93 @@ +<Type Name="Constraints+Class15" FullName="Constraints+Class15"> + <TypeSignature Language="C#" Value="public class Constraints.Class15" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constraints/Class15 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class15 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class15 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="add<T>"> + <MemberSignature Language="C#" Value="public static T add<T> (T value1, T value2);" /> + <MemberSignature Language="ILAsm" Value=".method public static !!T add<T>(!!T value1, !!T value2) cil managed" /> + <MemberSignature Language="F#" Value="static member add : 'T * 'T -> 'T" Usage="Constraints.Class15.add (value1, value2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>T</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Parameters> + <Parameter Name="value1" Type="T" /> + <Parameter Name="value2" Type="T" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="value1">To be added.</param> + <param name="value2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="heterogenousAdd<T,U>"> + <MemberSignature Language="C#" Value="public static T heterogenousAdd<T,U> (T value1, U value2);" /> + <MemberSignature Language="ILAsm" Value=".method public static !!T heterogenousAdd<T, U>(!!T value1, !!U value2) cil managed" /> + <MemberSignature Language="F#" Value="static member heterogenousAdd : 'T * 'U -> 'T" Usage="Constraints.Class15.heterogenousAdd (value1, value2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>T</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + <TypeParameter Name="U" /> + </TypeParameters> + <Parameters> + <Parameter Name="value1" Type="T" /> + <Parameter Name="value2" Type="U" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <typeparam name="U">To be added.</typeparam> + <param name="value1">To be added.</param> + <param name="value2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class16.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class16.xml new file mode 100644 index 00000000..b43b9f92 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class16.xml @@ -0,0 +1,63 @@ +<Type Name="Constraints+Class16" FullName="Constraints+Class16"> + <TypeSignature Language="C#" Value="public class Constraints.Class16" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constraints/Class16 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class16 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class16 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="method<T>"> + <MemberSignature Language="C#" Value="public static void method<T> (T value1, T value2);" /> + <MemberSignature Language="ILAsm" Value=".method public static void method<T>(!!T value1, !!T value2) cil managed" /> + <MemberSignature Language="F#" Value="static member method : 'T * 'T -> unit" Usage="Constraints.Class16.method (value1, value2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Parameters> + <Parameter Name="value1" Type="T" /> + <Parameter Name="value2" Type="T" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="value1">To be added.</param> + <param name="value2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class17.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class17.xml new file mode 100644 index 00000000..73e69d56 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class17.xml @@ -0,0 +1,67 @@ +<Type Name="Constraints+Class17" FullName="Constraints+Class17"> + <TypeSignature Language="C#" Value="public class Constraints.Class17" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constraints/Class17 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class17 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class17 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="method<T>"> + <MemberSignature Language="C#" Value="public static void method<T> (T value1, T value2) where T : class;" /> + <MemberSignature Language="ILAsm" Value=".method public static void method<class T>(!!T value1, !!T value2) cil managed" /> + <MemberSignature Language="F#" Value="static member method : 'T * 'T -> unit (requires 'T : null)" Usage="Constraints.Class17.method (value1, value2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <ParameterAttribute>ReferenceTypeConstraint</ParameterAttribute> + </Constraints> + </TypeParameter> + </TypeParameters> + <Parameters> + <Parameter Name="value1" Type="T" /> + <Parameter Name="value2" Type="T" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="value1">To be added.</param> + <param name="value2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class18.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class18.xml new file mode 100644 index 00000000..ca37c006 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class18.xml @@ -0,0 +1,59 @@ +<Type Name="Constraints+Class18" FullName="Constraints+Class18"> + <TypeSignature Language="C#" Value="public class Constraints.Class18" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constraints/Class18 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class18 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class18 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="method"> + <MemberSignature Language="C#" Value="public static void method (object value1, object value2);" /> + <MemberSignature Language="ILAsm" Value=".method public static void method(object value1, object value2) cil managed" /> + <MemberSignature Language="F#" Value="static member method : obj * obj -> unit" Usage="Constraints.Class18.method (value1, value2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="value1" Type="System.Object" /> + <Parameter Name="value2" Type="System.Object" /> + </Parameters> + <Docs> + <param name="value1">To be added.</param> + <param name="value2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class1`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class1`1.xml new file mode 100644 index 00000000..ea6236c0 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class1`1.xml @@ -0,0 +1,45 @@ +<Type Name="Constraints+Class1<T>" FullName="Constraints+Class1<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class1<T> where T : Exception" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class1`1<(class System.Exception) T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class1<'T (requires 'T :> Exception)> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <BaseTypeName>System.Exception</BaseTypeName> + </Constraints> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class2_1`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class2_1`1.xml new file mode 100644 index 00000000..678b98ea --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class2_1`1.xml @@ -0,0 +1,46 @@ +<Type Name="Constraints+Class2_1<T>" FullName="Constraints+Class2_1<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class2_1<T> where T : IComparable, Exception" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class2_1`1<(class System.IComparable, class System.Exception) T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class2_1<'T (requires 'T :> IComparable and 'T :> Exception)> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <InterfaceName>System.IComparable</InterfaceName> + <BaseTypeName>System.Exception</BaseTypeName> + </Constraints> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class2_1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class2`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class2`1.xml new file mode 100644 index 00000000..452b18ec --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class2`1.xml @@ -0,0 +1,45 @@ +<Type Name="Constraints+Class2<T>" FullName="Constraints+Class2<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class2<T> where T : IComparable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class2`1<(class System.IComparable) T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class2<'T (requires 'T :> IComparable)> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <InterfaceName>System.IComparable</InterfaceName> + </Constraints> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class2 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class3`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class3`1.xml new file mode 100644 index 00000000..49d40940 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class3`1.xml @@ -0,0 +1,45 @@ +<Type Name="Constraints+Class3<T>" FullName="Constraints+Class3<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class3<T> where T : class" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class3`1<class T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class3<'T (requires 'T : null)> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <ParameterAttribute>ReferenceTypeConstraint</ParameterAttribute> + </Constraints> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class3 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class4`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class4`1.xml new file mode 100644 index 00000000..dfe1f784 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class4`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class4<T>" FullName="Constraints+Class4<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class4<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class4`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class4<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class4 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class5`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class5`1.xml new file mode 100644 index 00000000..6036ef76 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class5`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class5<T>" FullName="Constraints+Class5<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class5<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class5`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class5<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class5 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class6`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class6`1.xml new file mode 100644 index 00000000..e083f544 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class6`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class6<T>" FullName="Constraints+Class6<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class6<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class6`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class6<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class6 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class7`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class7`1.xml new file mode 100644 index 00000000..bd29d46e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class7`1.xml @@ -0,0 +1,45 @@ +<Type Name="Constraints+Class7<T>" FullName="Constraints+Class7<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class7<T> where T : new()" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class7`1<.ctor T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class7<'T (requires 'T : (new : unit -> 'T))> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <ParameterAttribute>DefaultConstructorConstraint</ParameterAttribute> + </Constraints> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class7 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class8`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class8`1.xml new file mode 100644 index 00000000..672e6404 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class8`1.xml @@ -0,0 +1,45 @@ +<Type Name="Constraints+Class8<T>" FullName="Constraints+Class8<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class8<T> where T : class" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class8`1<class T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class8<'T (requires 'T : null)> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <ParameterAttribute>ReferenceTypeConstraint</ParameterAttribute> + </Constraints> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class8 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints+Class9`1.xml b/mdoc/Test/en.expected-fsharp/Constraints+Class9`1.xml new file mode 100644 index 00000000..ab9ff757 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints+Class9`1.xml @@ -0,0 +1,41 @@ +<Type Name="Constraints+Class9<T>" FullName="Constraints+Class9<T>"> + <TypeSignature Language="C#" Value="public class Constraints.Class9<T>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Constraints/Class9`1<T> extends System.Object" /> + <TypeSignature Language="F#" Value="type Constraints.Class9<'T> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="T">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class9 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constraints.xml b/mdoc/Test/en.expected-fsharp/Constraints.xml new file mode 100644 index 00000000..3b205dc0 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constraints.xml @@ -0,0 +1,23 @@ +<Type Name="Constraints" FullName="Constraints"> + <TypeSignature Language="C#" Value="public static class Constraints" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Constraints extends System.Object" /> + <TypeSignature Language="F#" Value="module Constraints" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+Account.xml b/mdoc/Test/en.expected-fsharp/Constructors+Account.xml new file mode 100644 index 00000000..2ec7aab8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+Account.xml @@ -0,0 +1,145 @@ +<Type Name="Constructors+Account" FullName="Constructors+Account"> + <TypeSignature Language="C#" Value="public class Constructors.Account" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/Account extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.Account = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Account ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="AccountNumber"> + <MemberSignature Language="C#" Value="public int AccountNumber { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 AccountNumber" /> + <MemberSignature Language="F#" Value="member this.AccountNumber : int with get, set" Usage="Constructors.Account.AccountNumber" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Balance"> + <MemberSignature Language="C#" Value="public double Balance { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Balance" /> + <MemberSignature Language="F#" Value="member this.Balance : double with get, set" Usage="Constructors.Account.Balance" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Deposit"> + <MemberSignature Language="C#" Value="public void Deposit (double amount);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Deposit(float64 amount) cil managed" /> + <MemberSignature Language="F#" Value="member this.Deposit : double -> unit" Usage="account.Deposit amount" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="amount" Type="System.Double" /> + </Parameters> + <Docs> + <param name="amount">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="FirstName"> + <MemberSignature Language="C#" Value="public string FirstName { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string FirstName" /> + <MemberSignature Language="F#" Value="member this.FirstName : string with get, set" Usage="Constructors.Account.FirstName" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="LastName"> + <MemberSignature Language="C#" Value="public string LastName { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string LastName" /> + <MemberSignature Language="F#" Value="member this.LastName : string with get, set" Usage="Constructors.Account.LastName" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Withdraw"> + <MemberSignature Language="C#" Value="public void Withdraw (double amount);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Withdraw(float64 amount) cil managed" /> + <MemberSignature Language="F#" Value="member this.Withdraw : double -> unit" Usage="account.Withdraw amount" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="amount" Type="System.Double" /> + </Parameters> + <Docs> + <param name="amount">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+Account2.xml b/mdoc/Test/en.expected-fsharp/Constructors+Account2.xml new file mode 100644 index 00000000..733cbaf0 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+Account2.xml @@ -0,0 +1,173 @@ +<Type Name="Constructors+Account2" FullName="Constructors+Account2"> + <TypeSignature Language="C#" Value="public class Constructors.Account2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/Account2 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.Account2 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Account2 (int accountNumber, Microsoft.FSharp.Core.FSharpOption<string> first, Microsoft.FSharp.Core.FSharpOption<string> last, Microsoft.FSharp.Core.FSharpOption<double> bal);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 accountNumber, class Microsoft.FSharp.Core.FSharpOption`1<string> first, class Microsoft.FSharp.Core.FSharpOption`1<string> last, class Microsoft.FSharp.Core.FSharpOption`1<float64> bal) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.Account2 : int * option<string> * option<string> * option<double> -> Constructors.Account2" Usage="new Constructors.Account2 (accountNumber, first, last, bal)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="accountNumber" Type="System.Int32" /> + <Parameter Name="first" Type="Microsoft.FSharp.Core.FSharpOption<System.String>"> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.OptionalArgument</AttributeName> + </Attribute> + </Attributes> + </Parameter> + <Parameter Name="last" Type="Microsoft.FSharp.Core.FSharpOption<System.String>"> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.OptionalArgument</AttributeName> + </Attribute> + </Attributes> + </Parameter> + <Parameter Name="bal" Type="Microsoft.FSharp.Core.FSharpOption<System.Double>"> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.OptionalArgument</AttributeName> + </Attribute> + </Attributes> + </Parameter> + </Parameters> + <Docs> + <param name="accountNumber">To be added.</param> + <param name="first">To be added.</param> + <param name="last">To be added.</param> + <param name="bal">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="AccountNumber"> + <MemberSignature Language="C#" Value="public int AccountNumber { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 AccountNumber" /> + <MemberSignature Language="F#" Value="member this.AccountNumber : int with get, set" Usage="Constructors.Account2.AccountNumber" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Balance"> + <MemberSignature Language="C#" Value="public double Balance { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Balance" /> + <MemberSignature Language="F#" Value="member this.Balance : double with get, set" Usage="Constructors.Account2.Balance" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Deposit"> + <MemberSignature Language="C#" Value="public void Deposit (double amount);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Deposit(float64 amount) cil managed" /> + <MemberSignature Language="F#" Value="member this.Deposit : double -> unit" Usage="account2.Deposit amount" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="amount" Type="System.Double" /> + </Parameters> + <Docs> + <param name="amount">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="FirstName"> + <MemberSignature Language="C#" Value="public string FirstName { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string FirstName" /> + <MemberSignature Language="F#" Value="member this.FirstName : string with get, set" Usage="Constructors.Account2.FirstName" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="LastName"> + <MemberSignature Language="C#" Value="public string LastName { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string LastName" /> + <MemberSignature Language="F#" Value="member this.LastName : string with get, set" Usage="Constructors.Account2.LastName" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Withdraw"> + <MemberSignature Language="C#" Value="public void Withdraw (double amount);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Withdraw(float64 amount) cil managed" /> + <MemberSignature Language="F#" Value="member this.Withdraw : double -> unit" Usage="account2.Withdraw amount" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="amount" Type="System.Double" /> + </Parameters> + <Docs> + <param name="amount">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+BaseClass.xml b/mdoc/Test/en.expected-fsharp/Constructors+BaseClass.xml new file mode 100644 index 00000000..239a481a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+BaseClass.xml @@ -0,0 +1,76 @@ +<Type Name="Constructors+BaseClass" FullName="Constructors+BaseClass"> + <TypeSignature Language="C#" Value="public class Constructors.BaseClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/BaseClass extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.BaseClass = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public BaseClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public BaseClass (string str);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string str) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.BaseClass : string -> Constructors.BaseClass" Usage="new Constructors.BaseClass str" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="str" Type="System.String" /> + </Parameters> + <Docs> + <param name="str">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="string1"> + <MemberSignature Language="C#" Value="public string string1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string string1" /> + <MemberSignature Language="F#" Value="val string1 : string" Usage="Constructors.BaseClass.string1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+DerivedClass.xml b/mdoc/Test/en.expected-fsharp/Constructors+DerivedClass.xml new file mode 100644 index 00000000..0d23a0f0 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+DerivedClass.xml @@ -0,0 +1,82 @@ +<Type Name="Constructors+DerivedClass" FullName="Constructors+DerivedClass"> + <TypeSignature Language="C#" Value="public class Constructors.DerivedClass : Constructors.BaseClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/DerivedClass extends uctors/BaseClass" /> + <TypeSignature Language="F#" Value="type Constructors.DerivedClass = class
 inherit Constructors.BaseClass" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Constructors+BaseClass</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public DerivedClass (string str2);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string str2) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.DerivedClass : string -> Constructors.DerivedClass" Usage="new Constructors.DerivedClass str2" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="str2" Type="System.String" /> + </Parameters> + <Docs> + <param name="str2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public DerivedClass (string str1, string str2);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string str1, string str2) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.DerivedClass : string * string -> Constructors.DerivedClass" Usage="new Constructors.DerivedClass (str1, str2)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="str1" Type="System.String" /> + <Parameter Name="str2" Type="System.String" /> + </Parameters> + <Docs> + <param name="str1">To be added.</param> + <param name="str2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="string2"> + <MemberSignature Language="C#" Value="public string string2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string string2" /> + <MemberSignature Language="F#" Value="val string2 : string" Usage="Constructors.DerivedClass.string2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass.xml new file mode 100644 index 00000000..24d283ce --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass.xml @@ -0,0 +1,109 @@ +<Type Name="Constructors+MyClass" FullName="Constructors+MyClass"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass (int x0, int y0, int z0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x0, int32 y0, int32 z0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClass : int * int * int -> Constructors.MyClass" Usage="new Constructors.MyClass (x0, y0, z0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x0" Type="System.Int32" /> + <Parameter Name="y0" Type="System.Int32" /> + <Parameter Name="z0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x0">To be added.</param> + <param name="y0">To be added.</param> + <param name="z0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public int X { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 X" /> + <MemberSignature Language="F#" Value="member this.X : int with get, set" Usage="Constructors.MyClass.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public int Y { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Y" /> + <MemberSignature Language="F#" Value="member this.Y : int with get, set" Usage="Constructors.MyClass.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Z"> + <MemberSignature Language="C#" Value="public int Z { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Z" /> + <MemberSignature Language="F#" Value="member this.Z : int with get, set" Usage="Constructors.MyClass.Z" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass1.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass1.xml new file mode 100644 index 00000000..3848a7cf --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass1.xml @@ -0,0 +1,58 @@ +<Type Name="Constructors+MyClass1" FullName="Constructors+MyClass1"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass1 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass1 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClass1 : int -> Constructors.MyClass1" Usage="new Constructors.MyClass1 x" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public int X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 X" /> + <MemberSignature Language="F#" Value="member this.X : int" Usage="Constructors.MyClass1.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass2.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass2.xml new file mode 100644 index 00000000..874b9551 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass2.xml @@ -0,0 +1,71 @@ +<Type Name="Constructors+MyClass2" FullName="Constructors+MyClass2"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass2 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass2 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass2 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass2 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClass2 : int -> Constructors.MyClass2" Usage="new Constructors.MyClass2 x" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public int X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 X" /> + <MemberSignature Language="F#" Value="member this.X : int" Usage="Constructors.MyClass2.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass3.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3.xml new file mode 100644 index 00000000..51ae3883 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3.xml @@ -0,0 +1,87 @@ +<Type Name="Constructors+MyClass3" FullName="Constructors+MyClass3"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass3" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass3 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass3 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass3 (int a0, int b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClass3 : int * int -> Constructors.MyClass3" Usage="new Constructors.MyClass3 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 a" /> + <MemberSignature Language="F#" Value="val a : int" Usage="Constructors.MyClass3.a" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 b" /> + <MemberSignature Language="F#" Value="val b : int" Usage="Constructors.MyClass3.b" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_1.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_1.xml new file mode 100644 index 00000000..b0d1daba --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_1.xml @@ -0,0 +1,43 @@ +<Type Name="Constructors+MyClass3_1" FullName="Constructors+MyClass3_1"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass3_1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass3_1 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass3_1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass3_1 (int a0, int b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClass3_1 : int * int -> Constructors.MyClass3_1" Usage="new Constructors.MyClass3_1 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_2.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_2.xml new file mode 100644 index 00000000..f211d734 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_2.xml @@ -0,0 +1,63 @@ +<Type Name="Constructors+MyClass3_2" FullName="Constructors+MyClass3_2"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass3_2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass3_2 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass3_2 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 a" /> + <MemberSignature Language="F#" Value="val a : int" Usage="Constructors.MyClass3_2.a" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 b" /> + <MemberSignature Language="F#" Value="member this.b : int" Usage="Constructors.MyClass3_2.b" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_3.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_3.xml new file mode 100644 index 00000000..8231af9c --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_3.xml @@ -0,0 +1,58 @@ +<Type Name="Constructors+MyClass3_3" FullName="Constructors+MyClass3_3"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass3_3" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass3_3 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass3_3 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass3_3 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 b" /> + <MemberSignature Language="F#" Value="val mutable b : int" Usage="Constructors.MyClass3_3.b" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_4.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_4.xml new file mode 100644 index 00000000..5688f52e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClass3_4.xml @@ -0,0 +1,85 @@ +<Type Name="Constructors+MyClass3_4" FullName="Constructors+MyClass3_4"> + <TypeSignature Language="C#" Value="public class Constructors.MyClass3_4" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClass3_4 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClass3_4 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass3_4 (object a0, object b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(object a0, object b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClass3_4 : obj * obj -> Constructors.MyClass3_4" Usage="new Constructors.MyClass3_4 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Object" /> + <Parameter Name="b0" Type="System.Object" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 a" /> + <MemberSignature Language="F#" Value="val mutable a : int" Usage="Constructors.MyClass3_4.a" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 b" /> + <MemberSignature Language="F#" Value="val mutable b : int" Usage="Constructors.MyClass3_4.b" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClassBase2.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClassBase2.xml new file mode 100644 index 00000000..8716092c --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClassBase2.xml @@ -0,0 +1,41 @@ +<Type Name="Constructors+MyClassBase2" FullName="Constructors+MyClassBase2"> + <TypeSignature Language="C#" Value="public class Constructors.MyClassBase2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClassBase2 extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClassBase2 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassBase2 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClassBase2 : int -> Constructors.MyClassBase2" Usage="new Constructors.MyClassBase2 x" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClassDerived2.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClassDerived2.xml new file mode 100644 index 00000000..ece16985 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClassDerived2.xml @@ -0,0 +1,41 @@ +<Type Name="Constructors+MyClassDerived2" FullName="Constructors+MyClassDerived2"> + <TypeSignature Language="C#" Value="public class Constructors.MyClassDerived2 : Constructors.MyClassBase2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClassDerived2 extends uctors/MyClassBase2" /> + <TypeSignature Language="F#" Value="type Constructors.MyClassDerived2 = class
 inherit Constructors.MyClassBase2" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Constructors+MyClassBase2</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassDerived2 (int y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 y) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClassDerived2 : int -> Constructors.MyClassDerived2" Usage="new Constructors.MyClassDerived2 y" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="y" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyClassObjectParameters.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyClassObjectParameters.xml new file mode 100644 index 00000000..f3ec532a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyClassObjectParameters.xml @@ -0,0 +1,79 @@ +<Type Name="Constructors+MyClassObjectParameters" FullName="Constructors+MyClassObjectParameters"> + <TypeSignature Language="C#" Value="public class Constructors.MyClassObjectParameters" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyClassObjectParameters extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyClassObjectParameters = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassObjectParameters (string x0, object y0, object z0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string x0, object y0, object z0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyClassObjectParameters : string * obj * obj -> Constructors.MyClassObjectParameters" Usage="new Constructors.MyClassObjectParameters (x0, y0, z0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x0" Type="System.String" /> + <Parameter Name="y0" Type="System.Object" /> + <Parameter Name="z0" Type="System.Object" /> + </Parameters> + <Docs> + <param name="x0">To be added.</param> + <param name="y0">To be added.</param> + <param name="z0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public string X { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string X" /> + <MemberSignature Language="F#" Value="member this.X : string with get, set" Usage="Constructors.MyClassObjectParameters.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public object Y { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance object Y" /> + <MemberSignature Language="F#" Value="member this.Y : obj with get, set" Usage="Constructors.MyClassObjectParameters.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Object</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct.xml new file mode 100644 index 00000000..a6163f23 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct.xml @@ -0,0 +1,288 @@ +<Type Name="Constructors+MyStruct" FullName="Constructors+MyStruct"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct : IComparable, IComparable<Constructors.MyStruct>, IEquatable<Constructors.MyStruct>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct>, class System.IEquatable`1<Constructors/MyStruct>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct (int x, int y, int z);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x, int32 y, int32 z) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct : int * int * int -> Constructors.MyStruct" Usage="new Constructors.MyStruct (x, y, z)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + <Parameter Name="y" Type="System.Int32" /> + <Parameter Name="z" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="z">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public int X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 X" /> + <MemberSignature Language="F#" Value="val X : int" Usage="Constructors.MyStruct.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public int Y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Y" /> + <MemberSignature Language="F#" Value="val Y : int" Usage="Constructors.MyStruct.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Z"> + <MemberSignature Language="C#" Value="public int Z { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Z" /> + <MemberSignature Language="F#" Value="val Z : int" Usage="Constructors.MyStruct.Z" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct2.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct2.xml new file mode 100644 index 00000000..e088a7e0 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct2.xml @@ -0,0 +1,264 @@ +<Type Name="Constructors+MyStruct2" FullName="Constructors+MyStruct2"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct2 : IComparable, IComparable<Constructors.MyStruct2>, IEquatable<Constructors.MyStruct2>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct2 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct2>, class System.IEquatable`1<Constructors/MyStruct2>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct2 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct2></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct2></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct2 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct2 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct2" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct2 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct2 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct2" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public int X;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 X" /> + <MemberSignature Language="F#" Value="val mutable X : int" Usage="Constructors.MyStruct2.X" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public int Y;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 Y" /> + <MemberSignature Language="F#" Value="val mutable Y : int" Usage="Constructors.MyStruct2.Y" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Z"> + <MemberSignature Language="C#" Value="public int Z;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 Z" /> + <MemberSignature Language="F#" Value="val mutable Z : int" Usage="Constructors.MyStruct2.Z" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct33.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct33.xml new file mode 100644 index 00000000..67dc1b06 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct33.xml @@ -0,0 +1,300 @@ +<Type Name="Constructors+MyStruct33" FullName="Constructors+MyStruct33"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct33 : IComparable, IComparable<Constructors.MyStruct33>, IEquatable<Constructors.MyStruct33>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct33 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct33>, class System.IEquatable`1<Constructors/MyStruct33>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct33 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct33></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct33></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct33 (int a0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct33 : int -> Constructors.MyStruct33" Usage="new Constructors.MyStruct33 a0" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct33 (int a0, int b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct33 : int * int -> Constructors.MyStruct33" Usage="new Constructors.MyStruct33 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct33 (int a0, int b0, int c0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0, int32 c0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct33 : int * int * int -> Constructors.MyStruct33" Usage="new Constructors.MyStruct33 (a0, b0, c0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + <Parameter Name="c0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <param name="c0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 a" /> + <MemberSignature Language="F#" Value="val mutable a : int" Usage="Constructors.MyStruct33.a" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 b" /> + <MemberSignature Language="F#" Value="val mutable b : int" Usage="Constructors.MyStruct33.b" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct33 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct33 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct33" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct33 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct33 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct33" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct44.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct44.xml new file mode 100644 index 00000000..5115c1bc --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct44.xml @@ -0,0 +1,262 @@ +<Type Name="Constructors+MyStruct44" FullName="Constructors+MyStruct44"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct44 : IComparable, IComparable<Constructors.MyStruct44>, IEquatable<Constructors.MyStruct44>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct44 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct44>, class System.IEquatable`1<Constructors/MyStruct44>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct44 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct44></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct44></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct44 (int a0, int b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct44 : int * int -> Constructors.MyStruct44" Usage="new Constructors.MyStruct44 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 a" /> + <MemberSignature Language="F#" Value="val mutable a : int" Usage="Constructors.MyStruct44.a" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 b" /> + <MemberSignature Language="F#" Value="val mutable b : int" Usage="Constructors.MyStruct44.b" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct44 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct44 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct44" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct44 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct44 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct44" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct55.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct55.xml new file mode 100644 index 00000000..b1963a4f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct55.xml @@ -0,0 +1,279 @@ +<Type Name="Constructors+MyStruct55" FullName="Constructors+MyStruct55"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct55 : IComparable, IComparable<Constructors.MyStruct55>, IEquatable<Constructors.MyStruct55>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct55 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct55>, class System.IEquatable`1<Constructors/MyStruct55>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct55 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct55></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct55></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct55 (int a0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct55 : int -> Constructors.MyStruct55" Usage="new Constructors.MyStruct55 a0" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct55 (int a0, int b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct55 : int * int -> Constructors.MyStruct55" Usage="new Constructors.MyStruct55 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 a" /> + <MemberSignature Language="F#" Value="val mutable a : int" Usage="Constructors.MyStruct55.a" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 b" /> + <MemberSignature Language="F#" Value="val mutable b : int" Usage="Constructors.MyStruct55.b" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct55 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct55 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct55" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct55 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct55 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct55" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct66.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct66.xml new file mode 100644 index 00000000..da35c98b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct66.xml @@ -0,0 +1,262 @@ +<Type Name="Constructors+MyStruct66" FullName="Constructors+MyStruct66"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct66 : IComparable, IComparable<Constructors.MyStruct66>, IEquatable<Constructors.MyStruct66>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct66 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct66>, class System.IEquatable`1<Constructors/MyStruct66>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct66 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct66></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct66></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct66 (int a0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct66 : int -> Constructors.MyStruct66" Usage="new Constructors.MyStruct66 a0" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 a" /> + <MemberSignature Language="F#" Value="val a : int" Usage="Constructors.MyStruct66.a" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 b" /> + <MemberSignature Language="F#" Value="val b : int" Usage="Constructors.MyStruct66.b" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct66 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct66 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct66" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct66 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct66 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct66" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct77.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct77.xml new file mode 100644 index 00000000..6f45c0c5 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct77.xml @@ -0,0 +1,261 @@ +<Type Name="Constructors+MyStruct77" FullName="Constructors+MyStruct77"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct77 : IComparable, IComparable<Constructors.MyStruct77>, IEquatable<Constructors.MyStruct77>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct77 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct77>, class System.IEquatable`1<Constructors/MyStruct77>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct77 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct77></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct77></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct77 (int a0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct77 : int -> Constructors.MyStruct77" Usage="new Constructors.MyStruct77 a0" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 a" /> + <MemberSignature Language="F#" Value="val mutable a : int" Usage="Constructors.MyStruct77.a" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 b" /> + <MemberSignature Language="F#" Value="val b : int" Usage="Constructors.MyStruct77.b" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct77 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct77 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct77" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct77 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct77 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct77" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyStruct88.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct88.xml new file mode 100644 index 00000000..b6961137 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyStruct88.xml @@ -0,0 +1,280 @@ +<Type Name="Constructors+MyStruct88" FullName="Constructors+MyStruct88"> + <TypeSignature Language="C#" Value="public struct Constructors.MyStruct88 : IComparable, IComparable<Constructors.MyStruct88>, IEquatable<Constructors.MyStruct88>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Constructors/MyStruct88 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/MyStruct88>, class System.IEquatable`1<Constructors/MyStruct88>" /> + <TypeSignature Language="F#" Value="type Constructors.MyStruct88 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+MyStruct88></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+MyStruct88></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct88 (int a0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct88 : int -> Constructors.MyStruct88" Usage="new Constructors.MyStruct88 a0" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyStruct88 (int a0, int b0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a0, int32 b0) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.MyStruct88 : int * int -> Constructors.MyStruct88" Usage="new Constructors.MyStruct88 (a0, b0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Int32" /> + <Parameter Name="b0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="a"> + <MemberSignature Language="C#" Value="public int a;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 a" /> + <MemberSignature Language="F#" Value="val mutable a : int" Usage="Constructors.MyStruct88.a" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.DefaultValue</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="b"> + <MemberSignature Language="C#" Value="public int b { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 b" /> + <MemberSignature Language="F#" Value="val b : int" Usage="Constructors.MyStruct88.b" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.MyStruct88 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/MyStruct88 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct88" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.MyStruct88 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/MyStruct88 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+MyStruct88" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+MyType.xml b/mdoc/Test/en.expected-fsharp/Constructors+MyType.xml new file mode 100644 index 00000000..0120490a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+MyType.xml @@ -0,0 +1,37 @@ +<Type Name="Constructors+MyType" FullName="Constructors+MyType"> + <TypeSignature Language="C#" Value="public class Constructors.MyType" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/MyType extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.MyType = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyType ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+Person.xml b/mdoc/Test/en.expected-fsharp/Constructors+Person.xml new file mode 100644 index 00000000..3aef0529 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+Person.xml @@ -0,0 +1,107 @@ +<Type Name="Constructors+Person" FullName="Constructors+Person"> + <TypeSignature Language="C#" Value="public class Constructors.Person" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/Person extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.Person = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Person ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Person (Constructors.Person person);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(Constructors/Person person) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.Person : Constructors.Person -> Constructors.Person" Usage="new Constructors.Person person" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="person" Type="Constructors+Person" /> + </Parameters> + <Docs> + <param name="person">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Person (string nameIn, int idIn);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string nameIn, int32 idIn) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.Person : string * int -> Constructors.Person" Usage="new Constructors.Person (nameIn, idIn)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="nameIn" Type="System.String" /> + <Parameter Name="idIn" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="nameIn">To be added.</param> + <param name="idIn">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ID"> + <MemberSignature Language="C#" Value="public int ID { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 ID" /> + <MemberSignature Language="F#" Value="member this.ID : int with get, set" Usage="Constructors.Person.ID" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Name"> + <MemberSignature Language="C#" Value="public string Name { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Name" /> + <MemberSignature Language="F#" Value="member this.Name : string with get, set" Usage="Constructors.Person.Name" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+Pet.xml b/mdoc/Test/en.expected-fsharp/Constructors+Pet.xml new file mode 100644 index 00000000..a850dfb5 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+Pet.xml @@ -0,0 +1,79 @@ +<Type Name="Constructors+Pet" FullName="Constructors+Pet"> + <TypeSignature Language="C#" Value="public class Constructors.Pet" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Constructors/Pet extends System.Object" /> + <TypeSignature Language="F#" Value="type Constructors.Pet = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Pet (Constructors.PetData data);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(Constructors/PetData data) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.Pet : Constructors.PetData -> Constructors.Pet" Usage="new Constructors.Pet data" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="data" Type="Constructors+PetData" /> + </Parameters> + <Docs> + <param name="data">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Pet (string name);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string name) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.Pet : string -> Constructors.Pet" Usage="new Constructors.Pet name" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="name" Type="System.String" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Pet (string name, int age, string animal);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string name, int32 age, string animal) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.Pet : string * int * string -> Constructors.Pet" Usage="new Constructors.Pet (name, age, animal)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="name" Type="System.String" /> + <Parameter Name="age" Type="System.Int32" /> + <Parameter Name="animal" Type="System.String" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <param name="age">To be added.</param> + <param name="animal">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors+PetData.xml b/mdoc/Test/en.expected-fsharp/Constructors+PetData.xml new file mode 100644 index 00000000..701e5f2b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors+PetData.xml @@ -0,0 +1,305 @@ +<Type Name="Constructors+PetData" FullName="Constructors+PetData"> + <TypeSignature Language="C#" Value="public sealed class Constructors.PetData : IComparable, IComparable<Constructors.PetData>, IEquatable<Constructors.PetData>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Constructors/PetData extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Constructors/PetData>, class System.IEquatable`1<Constructors/PetData>" /> + <TypeSignature Language="F#" Value="type Constructors.PetData = {}" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Constructors+PetData></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Constructors+PetData></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.RecordType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public PetData (string name, int age, string animal);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string name, int32 age, string animal) cil managed" /> + <MemberSignature Language="F#" Value="new Constructors.PetData : string * int * string -> Constructors.PetData" Usage="new Constructors.PetData (name, age, animal)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="name" Type="System.String" /> + <Parameter Name="age" Type="System.Int32" /> + <Parameter Name="animal" Type="System.String" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <param name="age">To be added.</param> + <param name="animal">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="age"> + <MemberSignature Language="C#" Value="public int age { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 age" /> + <MemberSignature Language="F#" Value="age : int" Usage="Constructors.PetData.age" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="animal"> + <MemberSignature Language="C#" Value="public string animal { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string animal" /> + <MemberSignature Language="F#" Value="animal : string" Usage="Constructors.PetData.animal" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Constructors.PetData obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Constructors/PetData obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+PetData" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Constructors.PetData obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Constructors/PetData obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Constructors+PetData" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="name"> + <MemberSignature Language="C#" Value="public string name { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string name" /> + <MemberSignature Language="F#" Value="name : string" Usage="Constructors.PetData.name" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Constructors.xml b/mdoc/Test/en.expected-fsharp/Constructors.xml new file mode 100644 index 00000000..f364556f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Constructors.xml @@ -0,0 +1,288 @@ +<Type Name="Constructors" FullName="Constructors"> + <TypeSignature Language="C#" Value="public static class Constructors" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Constructors extends System.Object" /> + <TypeSignature Language="F#" Value="module Constructors" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="account1"> + <MemberSignature Language="C#" Value="public static Constructors.Account account1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/Account account1" /> + <MemberSignature Language="F#" Value="Constructors.account1 : Constructors.Account" Usage="Constructors.account1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+Account</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="account2"> + <MemberSignature Language="C#" Value="public static Constructors.Account2 account2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/Account2 account2" /> + <MemberSignature Language="F#" Value="Constructors.account2 : Constructors.Account2" Usage="Constructors.account2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+Account2</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="myClassObj"> + <MemberSignature Language="C#" Value="public static Constructors.MyClass3 myClassObj { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/MyClass3 myClassObj" /> + <MemberSignature Language="F#" Value="Constructors.myClassObj : Constructors.MyClass3" Usage="Constructors.myClassObj" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+MyClass3</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="myStruct"> + <MemberSignature Language="C#" Value="public static Constructors.MyStruct33 myStruct { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/MyStruct33 myStruct" /> + <MemberSignature Language="F#" Value="Constructors.myStruct : Constructors.MyStruct33" Usage="Constructors.myStruct" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+MyStruct33</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="myStruct2"> + <MemberSignature Language="C#" Value="public static Constructors.MyStruct33 myStruct2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/MyStruct33 myStruct2" /> + <MemberSignature Language="F#" Value="Constructors.myStruct2 : Constructors.MyStruct33" Usage="Constructors.myStruct2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+MyStruct33</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="myStructure1"> + <MemberSignature Language="C#" Value="public static Constructors.MyStruct myStructure1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/MyStruct myStructure1" /> + <MemberSignature Language="F#" Value="Constructors.myStructure1 : Constructors.MyStruct" Usage="Constructors.myStructure1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+MyStruct</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="myStructure2"> + <MemberSignature Language="C#" Value="public static Constructors.MyStruct2 myStructure2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/MyStruct2 myStructure2" /> + <MemberSignature Language="F#" Value="Constructors.myStructure2 : Constructors.MyStruct2" Usage="Constructors.myStructure2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+MyStruct2</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="obj1"> + <MemberSignature Language="C#" Value="public static Constructors.DerivedClass obj1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/DerivedClass obj1" /> + <MemberSignature Language="F#" Value="Constructors.obj1 : Constructors.DerivedClass" Usage="Constructors.obj1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+DerivedClass</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="obj2"> + <MemberSignature Language="C#" Value="public static Constructors.DerivedClass obj2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/DerivedClass obj2" /> + <MemberSignature Language="F#" Value="Constructors.obj2 : Constructors.DerivedClass" Usage="Constructors.obj2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+DerivedClass</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="person1"> + <MemberSignature Language="C#" Value="public static Constructors.Person person1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/Person person1" /> + <MemberSignature Language="F#" Value="Constructors.person1 : Constructors.Person" Usage="Constructors.person1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+Person</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="person2"> + <MemberSignature Language="C#" Value="public static Constructors.Person person2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/Person person2" /> + <MemberSignature Language="F#" Value="Constructors.person2 : Constructors.Person" Usage="Constructors.person2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+Person</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="person3"> + <MemberSignature Language="C#" Value="public static Constructors.Person person3 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Constructors/Person person3" /> + <MemberSignature Language="F#" Value="Constructors.person3 : Constructors.Person" Usage="Constructors.person3" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Constructors+Person</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Customers+ICustomer.xml b/mdoc/Test/en.expected-fsharp/Customers+ICustomer.xml new file mode 100644 index 00000000..e6508bb5 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Customers+ICustomer.xml @@ -0,0 +1,55 @@ +<Type Name="Customers+ICustomer" FullName="Customers+ICustomer"> + <TypeSignature Language="C#" Value="public interface Customers.ICustomer" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable Customers/ICustomer" /> + <TypeSignature Language="F#" Value="type Customers.ICustomer = interface" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Age"> + <MemberSignature Language="C#" Value="public int Age { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Age" /> + <MemberSignature Language="F#" Value="member this.Age : int" Usage="Customers.ICustomer.Age" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Name"> + <MemberSignature Language="C#" Value="public string Name { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Name" /> + <MemberSignature Language="F#" Value="member this.Name : string" Usage="Customers.ICustomer.Name" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Customers.xml b/mdoc/Test/en.expected-fsharp/Customers.xml new file mode 100644 index 00000000..3c2afa83 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Customers.xml @@ -0,0 +1,52 @@ +<Type Name="Customers" FullName="Customers"> + <TypeSignature Language="C#" Value="public static class Customers" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Customers extends System.Object" /> + <TypeSignature Language="F#" Value="module Customers" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="createCustomer"> + <MemberSignature Language="C#" Value="public static Customers.ICustomer createCustomer (string name, int age);" /> + <MemberSignature Language="ILAsm" Value=".method public static Customers/ICustomer createCustomer(string name, int32 age) cil managed" /> + <MemberSignature Language="F#" Value="Customers.createCustomer : string -> int -> Customers.ICustomer" Usage="Customers.createCustomer name age" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Customers+ICustomer</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="name" Type="System.String" /> + <Parameter Name="age" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <param name="age">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate1.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate1.xml new file mode 100644 index 00000000..85a3643b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate1.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate1" FullName="Delegates+Delegate1"> + <TypeSignature Language="C#" Value="public delegate int Delegates.Delegate1(Tuple<int,int> );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate1 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate1 = delegate of (int * int) -> int" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Tuple<System.Int32,System.Int32>" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate10.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate10.xml new file mode 100644 index 00000000..67610d30 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate10.xml @@ -0,0 +1,30 @@ +<Type Name="Delegates+Delegate10" FullName="Delegates+Delegate10"> + <TypeSignature Language="C#" Value="public delegate char Delegates.Delegate10(int , int );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate10 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate10 = delegate of int * int -> char" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate11.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate11.xml new file mode 100644 index 00000000..212bdd16 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate11.xml @@ -0,0 +1,28 @@ +<Type Name="Delegates+Delegate11" FullName="Delegates+Delegate11"> + <TypeSignature Language="C#" Value="public delegate void Delegates.Delegate11(char );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate11 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate11 = delegate of char -> unit" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Char" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate12.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate12.xml new file mode 100644 index 00000000..9d056582 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate12.xml @@ -0,0 +1,26 @@ +<Type Name="Delegates+Delegate12" FullName="Delegates+Delegate12"> + <TypeSignature Language="C#" Value="public delegate char Delegates.Delegate12();" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate12 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate12 = delegate of unit -> char" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters /> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate13.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate13.xml new file mode 100644 index 00000000..d77a7ead --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate13.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate13" FullName="Delegates+Delegate13"> + <TypeSignature Language="C#" Value="public delegate double Delegates.Delegate13(FSharpFunc<int,FSharpFunc<char,FSharpFunc<string,decimal>>> );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate13 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate13 = delegate of (int -> char -> string -> decimal) -> double" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Char,Microsoft.FSharp.Core.FSharpFunc<System.String,System.Decimal>>>" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate2.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate2.xml new file mode 100644 index 00000000..08ecd38a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate2.xml @@ -0,0 +1,30 @@ +<Type Name="Delegates+Delegate2" FullName="Delegates+Delegate2"> + <TypeSignature Language="C#" Value="public delegate int Delegates.Delegate2(int , int );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate2 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate2 = delegate of int * int -> int" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate3.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate3.xml new file mode 100644 index 00000000..dd567554 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate3.xml @@ -0,0 +1,30 @@ +<Type Name="Delegates+Delegate3" FullName="Delegates+Delegate3"> + <TypeSignature Language="C#" Value="public delegate string Delegates.Delegate3(int , char );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate3 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate3 = delegate of int * char -> string" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Char" /> + </Parameters> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate4.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate4.xml new file mode 100644 index 00000000..edb90d60 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate4.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate4" FullName="Delegates+Delegate4"> + <TypeSignature Language="C#" Value="public delegate Microsoft.FSharp.Core.FSharpFunc<int,char> Delegates.Delegate4(int );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate4 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate4 = delegate of int -> (int -> char)" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Int32,System.Char></ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate5.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate5.xml new file mode 100644 index 00000000..fdd33034 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate5.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate5" FullName="Delegates+Delegate5"> + <TypeSignature Language="C#" Value="public delegate Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<char,string>> Delegates.Delegate5(int );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate5 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate5 = delegate of int -> (int -> char -> string)" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Char,System.String>></ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate6.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate6.xml new file mode 100644 index 00000000..cfa63e3a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate6.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate6" FullName="Delegates+Delegate6"> + <TypeSignature Language="C#" Value="public delegate char Delegates.Delegate6(FSharpFunc<int,double> );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate6 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate6 = delegate of (int -> double) -> char" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="Microsoft.FSharp.Core.FSharpFunc<System.Int32,System.Double>" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate7.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate7.xml new file mode 100644 index 00000000..6c47ebdb --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate7.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate7" FullName="Delegates+Delegate7"> + <TypeSignature Language="C#" Value="public delegate double Delegates.Delegate7(FSharpFunc<int,FSharpFunc<char,string>> );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate7 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate7 = delegate of (int -> char -> string) -> double" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Char,System.String>>" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate8.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate8.xml new file mode 100644 index 00000000..e1edcb5f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate8.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate8" FullName="Delegates+Delegate8"> + <TypeSignature Language="C#" Value="public delegate char Delegates.Delegate8(int );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate8 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate8 = delegate of int -> char" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Delegate9.xml b/mdoc/Test/en.expected-fsharp/Delegates+Delegate9.xml new file mode 100644 index 00000000..65f456dc --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Delegate9.xml @@ -0,0 +1,29 @@ +<Type Name="Delegates+Delegate9" FullName="Delegates+Delegate9"> + <TypeSignature Language="C#" Value="public delegate char Delegates.Delegate9(Tuple<int,int> );" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Delegates/Delegate9 extends System.MulticastDelegate" /> + <TypeSignature Language="F#" Value="type Delegates.Delegate9 = delegate of (int * int) -> char" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Delegate</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Parameters> + <Parameter Name="" Type="System.Tuple<System.Int32,System.Int32>" /> + </Parameters> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates+Test1.xml b/mdoc/Test/en.expected-fsharp/Delegates+Test1.xml new file mode 100644 index 00000000..bdc7ea5e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates+Test1.xml @@ -0,0 +1,139 @@ +<Type Name="Delegates+Test1" FullName="Delegates+Test1"> + <TypeSignature Language="C#" Value="public class Delegates.Test1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Delegates/Test1 extends System.Object" /> + <TypeSignature Language="F#" Value="type Delegates.Test1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Test1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="add"> + <MemberSignature Language="C#" Value="public static int add (int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 add(int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="static member add : int * int -> int" Usage="Delegates.Test1.add (a, b)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Add"> + <MemberSignature Language="C#" Value="public int Add (int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 Add(int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="member this.Add : int * int -> int" Usage="test1.Add (a, b)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="add2"> + <MemberSignature Language="C#" Value="public static int add2 (int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 add2(int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="static member add2 : int -> int -> int" Usage="Delegates.Test1.add2 a b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Add2"> + <MemberSignature Language="C#" Value="public int Add2 (int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 Add2(int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="member this.Add2 : int -> int -> int" Usage="test1.Add2 a b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Delegates.xml b/mdoc/Test/en.expected-fsharp/Delegates.xml new file mode 100644 index 00000000..7dda5b2c --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Delegates.xml @@ -0,0 +1,977 @@ +<Type Name="Delegates" FullName="Delegates"> + <TypeSignature Language="C#" Value="public static class Delegates" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Delegates extends System.Object" /> + <TypeSignature Language="F#" Value="module Delegates" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="del1"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate1 del1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate1 del1" /> + <MemberSignature Language="F#" Value="Delegates.del1 : Delegates.Delegate1" Usage="Delegates.del1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate1</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="del2"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate2 del2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate2 del2" /> + <MemberSignature Language="F#" Value="Delegates.del2 : Delegates.Delegate2" Usage="Delegates.del2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate2</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="del3"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate1 del3 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate1 del3" /> + <MemberSignature Language="F#" Value="Delegates.del3 : Delegates.Delegate1" Usage="Delegates.del3" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate1</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="del4"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate2 del4 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate2 del4" /> + <MemberSignature Language="F#" Value="Delegates.del4 : Delegates.Delegate2" Usage="Delegates.del4" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate2</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate3 delObject { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate3 delObject" /> + <MemberSignature Language="F#" Value="Delegates.delObject : Delegates.Delegate3" Usage="Delegates.delObject" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate3</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject1"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate1 delObject1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate1 delObject1" /> + <MemberSignature Language="F#" Value="Delegates.delObject1 : Delegates.Delegate1" Usage="Delegates.delObject1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate1</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject10"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate10 delObject10 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate10 delObject10" /> + <MemberSignature Language="F#" Value="Delegates.delObject10 : Delegates.Delegate10" Usage="Delegates.delObject10" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate10</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject11"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate11 delObject11 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate11 delObject11" /> + <MemberSignature Language="F#" Value="Delegates.delObject11 : Delegates.Delegate11" Usage="Delegates.delObject11" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate11</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject12"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate12 delObject12 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate12 delObject12" /> + <MemberSignature Language="F#" Value="Delegates.delObject12 : Delegates.Delegate12" Usage="Delegates.delObject12" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate12</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject12_1"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate12 delObject12_1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate12 delObject12_1" /> + <MemberSignature Language="F#" Value="Delegates.delObject12_1 : Delegates.Delegate12" Usage="Delegates.delObject12_1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate12</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject13"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate13 delObject13 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate13 delObject13" /> + <MemberSignature Language="F#" Value="Delegates.delObject13 : Delegates.Delegate13" Usage="Delegates.delObject13" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate13</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject2"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate2 delObject2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate2 delObject2" /> + <MemberSignature Language="F#" Value="Delegates.delObject2 : Delegates.Delegate2" Usage="Delegates.delObject2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate2</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject3"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate3 delObject3 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate3 delObject3" /> + <MemberSignature Language="F#" Value="Delegates.delObject3 : Delegates.Delegate3" Usage="Delegates.delObject3" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate3</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject4"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate4 delObject4 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate4 delObject4" /> + <MemberSignature Language="F#" Value="Delegates.delObject4 : Delegates.Delegate4" Usage="Delegates.delObject4" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate4</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject5"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate5 delObject5 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate5 delObject5" /> + <MemberSignature Language="F#" Value="Delegates.delObject5 : Delegates.Delegate5" Usage="Delegates.delObject5" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate5</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject6"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate6 delObject6 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate6 delObject6" /> + <MemberSignature Language="F#" Value="Delegates.delObject6 : Delegates.Delegate6" Usage="Delegates.delObject6" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate6</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject7"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate7 delObject7 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate7 delObject7" /> + <MemberSignature Language="F#" Value="Delegates.delObject7 : Delegates.Delegate7" Usage="Delegates.delObject7" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate7</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject8"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate8 delObject8 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate8 delObject8" /> + <MemberSignature Language="F#" Value="Delegates.delObject8 : Delegates.Delegate8" Usage="Delegates.delObject8" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate8</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="delObject9"> + <MemberSignature Language="C#" Value="public static Delegates.Delegate9 delObject9 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Delegate9 delObject9" /> + <MemberSignature Language="F#" Value="Delegates.delObject9 : Delegates.Delegate9" Usage="Delegates.delObject9" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Delegate9</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public static int function1 (int i, int i2);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function1(int32 i, int32 i2) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function1 : int * int -> int" Usage="Delegates.function1 (i, i2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + <Parameter Name="i2" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <param name="i2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function1_"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<char,string>> function1_ { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<char, string>> function1_" /> + <MemberSignature Language="F#" Value="Delegates.function1_ : int -> char -> string" Usage="Delegates.function1_" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Char,System.String>></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function10"> + <MemberSignature Language="C#" Value="public static char function10 (int i, int i2);" /> + <MemberSignature Language="ILAsm" Value=".method public static char function10(int32 i, int32 i2) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function10 : int -> int -> char" Usage="Delegates.function10 i i2" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + <Parameter Name="i2" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <param name="i2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function11"> + <MemberSignature Language="C#" Value="public static void function11 (char c);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function11(char c) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function11 : char -> unit" Usage="Delegates.function11 c" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="c" Type="System.Char" /> + </Parameters> + <Docs> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function12"> + <MemberSignature Language="C#" Value="public static char function12 (Microsoft.FSharp.Core.Unit c);" /> + <MemberSignature Language="ILAsm" Value=".method public static char function12(class Microsoft.FSharp.Core.Unit c) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function12 : unit -> char" Usage="Delegates.function12 c" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="c" Type="Microsoft.FSharp.Core.Unit" /> + </Parameters> + <Docs> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function12_1"> + <MemberSignature Language="C#" Value="public static char function12_1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public static char function12_1() cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function12_1 : unit -> char" Usage="Delegates.function12_1 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function13"> + <MemberSignature Language="C#" Value="public static double function13 (Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<char,Microsoft.FSharp.Core.FSharpFunc<string,decimal>>> intCharStringDecimalFunction);" /> + <MemberSignature Language="ILAsm" Value=".method public static float64 function13(class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<char, class Microsoft.FSharp.Core.FSharpFunc`2<string, valuetype System.Decimal>>> intCharStringDecimalFunction) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function13 : (int -> char -> string -> decimal) -> double" Usage="Delegates.function13 intCharStringDecimalFunction" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="intCharStringDecimalFunction" Type="Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Char,Microsoft.FSharp.Core.FSharpFunc<System.String,System.Decimal>>>" /> + </Parameters> + <Docs> + <param name="intCharStringDecimalFunction">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function2"> + <MemberSignature Language="C#" Value="public static int function2 (int i, int ch);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function2(int32 i, int32 ch) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function2 : int -> int -> int" Usage="Delegates.function2 i ch" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + <Parameter Name="ch" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <param name="ch">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function3"> + <MemberSignature Language="C#" Value="public static string function3 (int i, char s);" /> + <MemberSignature Language="ILAsm" Value=".method public static string function3(int32 i, char s) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function3 : int -> char -> string" Usage="Delegates.function3 i s" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + <Parameter Name="s" Type="System.Char" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <param name="s">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function4"> + <MemberSignature Language="C#" Value="public static char function4 (int i, int ch);" /> + <MemberSignature Language="ILAsm" Value=".method public static char function4(int32 i, int32 ch) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function4 : int -> int -> char" Usage="Delegates.function4 i ch" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + <Parameter Name="ch" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <param name="ch">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function5"> + <MemberSignature Language="C#" Value="public static string function5 (int i, int i2, char ch);" /> + <MemberSignature Language="ILAsm" Value=".method public static string function5(int32 i, int32 i2, char ch) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function5 : int -> int -> char -> string" Usage="Delegates.function5 i i2 ch" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + <Parameter Name="i2" Type="System.Int32" /> + <Parameter Name="ch" Type="System.Char" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <param name="i2">To be added.</param> + <param name="ch">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function6"> + <MemberSignature Language="C#" Value="public static char function6 (Microsoft.FSharp.Core.FSharpFunc<int,double> intIntFunction);" /> + <MemberSignature Language="ILAsm" Value=".method public static char function6(class Microsoft.FSharp.Core.FSharpFunc`2<int32, float64> intIntFunction) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function6 : (int -> double) -> char" Usage="Delegates.function6 intIntFunction" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="intIntFunction" Type="Microsoft.FSharp.Core.FSharpFunc<System.Int32,System.Double>" /> + </Parameters> + <Docs> + <param name="intIntFunction">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function7"> + <MemberSignature Language="C#" Value="public static double function7 (Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<char,string>> intCharStringFunction);" /> + <MemberSignature Language="ILAsm" Value=".method public static float64 function7(class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<char, string>> intCharStringFunction) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function7 : (int -> char -> string) -> double" Usage="Delegates.function7 intCharStringFunction" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="intCharStringFunction" Type="Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Char,System.String>>" /> + </Parameters> + <Docs> + <param name="intCharStringFunction">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function8"> + <MemberSignature Language="C#" Value="public static char function8 (int i);" /> + <MemberSignature Language="ILAsm" Value=".method public static char function8(int32 i) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function8 : int -> char" Usage="Delegates.function8 i" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function9"> + <MemberSignature Language="C#" Value="public static char function9 (int i_0, int i_1);" /> + <MemberSignature Language="ILAsm" Value=".method public static char function9(int32 i_0, int32 i_1) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.function9 : int * int -> char" Usage="Delegates.function9 (i_0, i_1)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i_0" Type="System.Int32" /> + <Parameter Name="i_1" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="i_0">To be added.</param> + <param name="i_1">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="functionValue"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Tuple<int,char>,string> functionValue { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<class System.Tuple`2<int32, char>, string> functionValue" /> + <MemberSignature Language="F#" Value="Delegates.functionValue : int * char -> string" Usage="Delegates.functionValue" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Tuple<System.Int32,System.Char>,System.String></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="InvokeDelegate1"> + <MemberSignature Language="C#" Value="public static int InvokeDelegate1 (Delegates.Delegate1 dlg, int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 InvokeDelegate1(Delegates/Delegate1 dlg, int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.InvokeDelegate1 : Delegates.Delegate1 -> int -> int -> int" Usage="Delegates.InvokeDelegate1 dlg a b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="dlg" Type="Delegates+Delegate1" /> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="dlg">To be added.</param> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="InvokeDelegate2"> + <MemberSignature Language="C#" Value="public static int InvokeDelegate2 (Delegates.Delegate2 dlg, int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 InvokeDelegate2(Delegates/Delegate2 dlg, int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.InvokeDelegate2 : Delegates.Delegate2 -> int -> int -> int" Usage="Delegates.InvokeDelegate2 dlg a b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="dlg" Type="Delegates+Delegate2" /> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="dlg">To be added.</param> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="replicate"> + <MemberSignature Language="C#" Value="public static string replicate (int n, char c);" /> + <MemberSignature Language="ILAsm" Value=".method public static string replicate(int32 n, char c) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.replicate : int -> char -> string" Usage="Delegates.replicate n c" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="n" Type="System.Int32" /> + <Parameter Name="c" Type="System.Char" /> + </Parameters> + <Docs> + <param name="n">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="replicate'"> + <MemberSignature Language="C#" Value="public static string replicate' (int n, char c);" /> + <MemberSignature Language="ILAsm" Value=".method public static string replicate'(int32 n, char c) cil managed" /> + <MemberSignature Language="F#" Value="Delegates.replicate' : int -> char -> string" Usage="Delegates.replicate' n c" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="n" Type="System.Int32" /> + <Parameter Name="c" Type="System.Char" /> + </Parameters> + <Docs> + <param name="n">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="stringArray"> + <MemberSignature Language="C#" Value="public static string[] stringArray { get; }" /> + <MemberSignature Language="ILAsm" Value=".property string[] stringArray" /> + <MemberSignature Language="F#" Value="Delegates.stringArray : string[]" Usage="Delegates.stringArray" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String[]</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="testObject"> + <MemberSignature Language="C#" Value="public static Delegates.Test1 testObject { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Delegates/Test1 testObject" /> + <MemberSignature Language="F#" Value="Delegates.testObject : Delegates.Test1" Usage="Delegates.testObject" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Delegates+Test1</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+ColorEnum.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+ColorEnum.xml new file mode 100644 index 00000000..f6dd6a05 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+ColorEnum.xml @@ -0,0 +1,71 @@ +<Type Name="DiscriminatedUnions+ColorEnum" FullName="DiscriminatedUnions+ColorEnum"> + <TypeSignature Language="C#" Value="public enum DiscriminatedUnions.ColorEnum" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed DiscriminatedUnions/ColorEnum extends System.Enum" /> + <TypeSignature Language="F#" Value="type DiscriminatedUnions.ColorEnum = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Enum</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Blue"> + <MemberSignature Language="C#" Value="Blue" /> + <MemberSignature Language="ILAsm" Value=".field public static literal DiscriminatedUnions/ColorEnum Blue = int32(9)" /> + <MemberSignature Language="F#" Value="Blue = 9" Usage="DiscriminatedUnions.ColorEnum.Blue" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>DiscriminatedUnions+ColorEnum</ReturnType> + </ReturnValue> + <MemberValue>9</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + <Member MemberName="Red"> + <MemberSignature Language="C#" Value="Red" /> + <MemberSignature Language="ILAsm" Value=".field public static literal DiscriminatedUnions/ColorEnum Red = int32(5)" /> + <MemberSignature Language="F#" Value="Red = 5" Usage="DiscriminatedUnions.ColorEnum.Red" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>DiscriminatedUnions+ColorEnum</ReturnType> + </ReturnValue> + <MemberValue>5</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + <Member MemberName="Yellow"> + <MemberSignature Language="C#" Value="Yellow" /> + <MemberSignature Language="ILAsm" Value=".field public static literal DiscriminatedUnions/ColorEnum Yellow = int32(7)" /> + <MemberSignature Language="F#" Value="Yellow = 7" Usage="DiscriminatedUnions.ColorEnum.Yellow" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>DiscriminatedUnions+ColorEnum</ReturnType> + </ReturnValue> + <MemberValue>7</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Circle.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Circle.xml new file mode 100644 index 00000000..c23a598d --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Circle.xml @@ -0,0 +1,55 @@ +<Type Name="DiscriminatedUnions+Shape+Circle" FullName="DiscriminatedUnions+Shape+Circle"> + <TypeSignature Language="C#" Value="public class DiscriminatedUnions.Shape.Circle : DiscriminatedUnions.Shape" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit DiscriminatedUnions/Shape/Circle extends minatedUnions/Shape" /> + <TypeSignature Language="F#" Value="DiscriminatedUnions.Shape.Circle : double -> DiscriminatedUnions.Shape" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>DiscriminatedUnions+Shape</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(DiscriminatedUnions/Shape/Circle@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="radius"> + <MemberSignature Language="C#" Value="public double radius { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 radius" /> + <MemberSignature Language="F#" Value="val radius : double" Usage="DiscriminatedUnions.Shape.Circle.radius" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Prism.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Prism.xml new file mode 100644 index 00000000..b4c04693 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Prism.xml @@ -0,0 +1,111 @@ +<Type Name="DiscriminatedUnions+Shape+Prism" FullName="DiscriminatedUnions+Shape+Prism"> + <TypeSignature Language="C#" Value="public class DiscriminatedUnions.Shape.Prism : DiscriminatedUnions.Shape" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit DiscriminatedUnions/Shape/Prism extends minatedUnions/Shape" /> + <TypeSignature Language="F#" Value="DiscriminatedUnions.Shape.Prism : double * double * double -> DiscriminatedUnions.Shape" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>DiscriminatedUnions+Shape</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(DiscriminatedUnions/Shape/Prism@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="height"> + <MemberSignature Language="C#" Value="public double height { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 height" /> + <MemberSignature Language="F#" Value="val height : double" Usage="DiscriminatedUnions.Shape.Prism.height" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2, 2)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Item2"> + <MemberSignature Language="C#" Value="public double Item2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Item2" /> + <MemberSignature Language="F#" Value="val Item2 : double" Usage="DiscriminatedUnions.Shape.Prism.Item2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2, 1)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="width"> + <MemberSignature Language="C#" Value="public double width { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 width" /> + <MemberSignature Language="F#" Value="val width : double" Usage="DiscriminatedUnions.Shape.Prism.width" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Rectangle.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Rectangle.xml new file mode 100644 index 00000000..3124d16b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Rectangle.xml @@ -0,0 +1,83 @@ +<Type Name="DiscriminatedUnions+Shape+Rectangle" FullName="DiscriminatedUnions+Shape+Rectangle"> + <TypeSignature Language="C#" Value="public class DiscriminatedUnions.Shape.Rectangle : DiscriminatedUnions.Shape" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit DiscriminatedUnions/Shape/Rectangle extends minatedUnions/Shape" /> + <TypeSignature Language="F#" Value="DiscriminatedUnions.Shape.Rectangle : double * double -> DiscriminatedUnions.Shape" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>DiscriminatedUnions+Shape</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(DiscriminatedUnions/Shape/Rectangle@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="length"> + <MemberSignature Language="C#" Value="public double length { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 length" /> + <MemberSignature Language="F#" Value="val length : double" Usage="DiscriminatedUnions.Shape.Rectangle.length" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0, 1)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="width"> + <MemberSignature Language="C#" Value="public double width { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 width" /> + <MemberSignature Language="F#" Value="val width : double" Usage="DiscriminatedUnions.Shape.Rectangle.width" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Tags.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Tags.xml new file mode 100644 index 00000000..bd2fadeb --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape+Tags.xml @@ -0,0 +1,69 @@ +<Type Name="DiscriminatedUnions+Shape+Tags" FullName="DiscriminatedUnions+Shape+Tags"> + <TypeSignature Language="C#" Value="public static class DiscriminatedUnions.Shape.Tags" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed DiscriminatedUnions/Shape/Tags extends System.Object" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Circle"> + <MemberSignature Language="C#" Value="public const int Circle = 1;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Circle = (1)" /> + <MemberSignature Language="F#" Value="val mutable Circle : int" Usage="DiscriminatedUnions.Shape.Tags.Circle" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>1</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Prism"> + <MemberSignature Language="C#" Value="public const int Prism = 2;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Prism = (2)" /> + <MemberSignature Language="F#" Value="val mutable Prism : int" Usage="DiscriminatedUnions.Shape.Tags.Prism" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>2</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rectangle"> + <MemberSignature Language="C#" Value="public const int Rectangle = 0;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Rectangle = (0)" /> + <MemberSignature Language="F#" Value="val mutable Rectangle : int" Usage="DiscriminatedUnions.Shape.Tags.Rectangle" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>0</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape.xml new file mode 100644 index 00000000..195291e8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+Shape.xml @@ -0,0 +1,410 @@ +<Type Name="DiscriminatedUnions+Shape" FullName="DiscriminatedUnions+Shape"> + <TypeSignature Language="C#" Value="public abstract class DiscriminatedUnions.Shape : IComparable, IComparable<DiscriminatedUnions.Shape>, IEquatable<DiscriminatedUnions.Shape>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto abstract serializable beforefieldinit DiscriminatedUnions/Shape extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<DiscriminatedUnions/Shape>, class System.IEquatable`1<DiscriminatedUnions/Shape>" /> + <TypeSignature Language="F#" Value="type DiscriminatedUnions.Shape = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<DiscriminatedUnions+Shape></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<DiscriminatedUnions+Shape></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.SumType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (DiscriminatedUnions.Shape obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(DiscriminatedUnions/Shape obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="DiscriminatedUnions+Shape" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (DiscriminatedUnions.Shape obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(DiscriminatedUnions/Shape obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="DiscriminatedUnions+Shape" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsCircle"> + <MemberSignature Language="C#" Value="public bool IsCircle { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsCircle" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsPrism"> + <MemberSignature Language="C#" Value="public bool IsPrism { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsPrism" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsRectangle"> + <MemberSignature Language="C#" Value="public bool IsRectangle { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsRectangle" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewCircle"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.Shape NewCircle (double _radius);" /> + <MemberSignature Language="ILAsm" Value=".method public static DiscriminatedUnions/Shape NewCircle(float64 _radius) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+Shape</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_radius" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_radius">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewPrism"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.Shape NewPrism (double _width, double item2, double _height);" /> + <MemberSignature Language="ILAsm" Value=".method public static DiscriminatedUnions/Shape NewPrism(float64 _width, float64 item2, float64 _height) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+Shape</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_width" Type="System.Double" /> + <Parameter Name="item2" Type="System.Double" /> + <Parameter Name="_height" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_width">To be added.</param> + <param name="item2">To be added.</param> + <param name="_height">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewRectangle"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.Shape NewRectangle (double _width, double _length);" /> + <MemberSignature Language="ILAsm" Value=".method public static DiscriminatedUnions/Shape NewRectangle(float64 _width, float64 _length) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+Shape</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_width" Type="System.Double" /> + <Parameter Name="_length" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_width">To be added.</param> + <param name="_length">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Tag"> + <MemberSignature Language="C#" Value="public int Tag { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Tag" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+SizeUnion+Tags.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+SizeUnion+Tags.xml new file mode 100644 index 00000000..c5f16709 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+SizeUnion+Tags.xml @@ -0,0 +1,69 @@ +<Type Name="DiscriminatedUnions+SizeUnion+Tags" FullName="DiscriminatedUnions+SizeUnion+Tags"> + <TypeSignature Language="C#" Value="public static class DiscriminatedUnions.SizeUnion.Tags" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed DiscriminatedUnions/SizeUnion/Tags extends System.Object" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Large"> + <MemberSignature Language="C#" Value="public const int Large = 2;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Large = (2)" /> + <MemberSignature Language="F#" Value="val mutable Large : int" Usage="DiscriminatedUnions.SizeUnion.Tags.Large" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>2</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Medium"> + <MemberSignature Language="C#" Value="public const int Medium = 1;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Medium = (1)" /> + <MemberSignature Language="F#" Value="val mutable Medium : int" Usage="DiscriminatedUnions.SizeUnion.Tags.Medium" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>1</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Small"> + <MemberSignature Language="C#" Value="public const int Small = 0;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Small = (0)" /> + <MemberSignature Language="F#" Value="val mutable Small : int" Usage="DiscriminatedUnions.SizeUnion.Tags.Small" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>0</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+SizeUnion.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+SizeUnion.xml new file mode 100644 index 00000000..391d3f2b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions+SizeUnion.xml @@ -0,0 +1,413 @@ +<Type Name="DiscriminatedUnions+SizeUnion" FullName="DiscriminatedUnions+SizeUnion"> + <TypeSignature Language="C#" Value="public sealed class DiscriminatedUnions.SizeUnion : IComparable, IComparable<DiscriminatedUnions.SizeUnion>, IEquatable<DiscriminatedUnions.SizeUnion>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto serializable sealed beforefieldinit DiscriminatedUnions/SizeUnion extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<DiscriminatedUnions/SizeUnion>, class System.IEquatable`1<DiscriminatedUnions/SizeUnion>" /> + <TypeSignature Language="F#" Value="type DiscriminatedUnions.SizeUnion = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<DiscriminatedUnions+SizeUnion></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<DiscriminatedUnions+SizeUnion></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.SumType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (DiscriminatedUnions.SizeUnion obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(DiscriminatedUnions/SizeUnion obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="DiscriminatedUnions+SizeUnion" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (DiscriminatedUnions.SizeUnion obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(DiscriminatedUnions/SizeUnion obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="DiscriminatedUnions+SizeUnion" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsLarge"> + <MemberSignature Language="C#" Value="public bool IsLarge { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsLarge" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsMedium"> + <MemberSignature Language="C#" Value="public bool IsMedium { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsMedium" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsSmall"> + <MemberSignature Language="C#" Value="public bool IsSmall { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsSmall" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Large"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.SizeUnion Large { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DiscriminatedUnions/SizeUnion Large" /> + <MemberSignature Language="F#" Value="member this.Large : DiscriminatedUnions.SizeUnion" Usage="DiscriminatedUnions.SizeUnion.Large" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+SizeUnion</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Medium"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.SizeUnion Medium { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DiscriminatedUnions/SizeUnion Medium" /> + <MemberSignature Language="F#" Value="member this.Medium : DiscriminatedUnions.SizeUnion" Usage="DiscriminatedUnions.SizeUnion.Medium" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+SizeUnion</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Small"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.SizeUnion Small { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DiscriminatedUnions/SizeUnion Small" /> + <MemberSignature Language="F#" Value="member this.Small : DiscriminatedUnions.SizeUnion" Usage="DiscriminatedUnions.SizeUnion.Small" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+SizeUnion</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Tag"> + <MemberSignature Language="C#" Value="public int Tag { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Tag" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DiscriminatedUnions.xml b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions.xml new file mode 100644 index 00000000..705a47e2 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DiscriminatedUnions.xml @@ -0,0 +1,90 @@ +<Type Name="DiscriminatedUnions" FullName="DiscriminatedUnions"> + <TypeSignature Language="C#" Value="public static class DiscriminatedUnions" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed DiscriminatedUnions extends System.Object" /> + <TypeSignature Language="F#" Value="module DiscriminatedUnions" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="circ"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.Shape circ { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DiscriminatedUnions/Shape circ" /> + <MemberSignature Language="F#" Value="DiscriminatedUnions.circ : DiscriminatedUnions.Shape" Usage="DiscriminatedUnions.circ" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+Shape</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="prism"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.Shape prism { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DiscriminatedUnions/Shape prism" /> + <MemberSignature Language="F#" Value="DiscriminatedUnions.prism : DiscriminatedUnions.Shape" Usage="DiscriminatedUnions.prism" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+Shape</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="rect"> + <MemberSignature Language="C#" Value="public static DiscriminatedUnions.Shape rect { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DiscriminatedUnions/Shape rect" /> + <MemberSignature Language="F#" Value="DiscriminatedUnions.rect : DiscriminatedUnions.Shape" Usage="DiscriminatedUnions.rect" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DiscriminatedUnions+Shape</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DoBindings+MyBindingType.xml b/mdoc/Test/en.expected-fsharp/DoBindings+MyBindingType.xml new file mode 100644 index 00000000..54a6ebc2 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DoBindings+MyBindingType.xml @@ -0,0 +1,95 @@ +<Type Name="DoBindings+MyBindingType" FullName="DoBindings+MyBindingType"> + <TypeSignature Language="C#" Value="public class DoBindings.MyBindingType" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable DoBindings/MyBindingType extends System.Object" /> + <TypeSignature Language="F#" Value="type DoBindings.MyBindingType = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyBindingType (int a, int b);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 a, int32 b) cil managed" /> + <MemberSignature Language="F#" Value="new DoBindings.MyBindingType : int * int -> DoBindings.MyBindingType" Usage="new DoBindings.MyBindingType (a, b)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Prop1"> + <MemberSignature Language="C#" Value="public int Prop1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Prop1" /> + <MemberSignature Language="F#" Value="member this.Prop1 : int" Usage="DoBindings.MyBindingType.Prop1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Prop2"> + <MemberSignature Language="C#" Value="public int Prop2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Prop2" /> + <MemberSignature Language="F#" Value="member this.Prop2 : int" Usage="DoBindings.MyBindingType.Prop2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance string ToString() cil managed" /> + <MemberSignature Language="F#" Value="override this.ToString : unit -> string" Usage="myBindingType.ToString " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/DoBindings.xml b/mdoc/Test/en.expected-fsharp/DoBindings.xml new file mode 100644 index 00000000..24f5d9c9 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/DoBindings.xml @@ -0,0 +1,46 @@ +<Type Name="DoBindings" FullName="DoBindings"> + <TypeSignature Language="C#" Value="public static class DoBindings" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed DoBindings extends System.Object" /> + <TypeSignature Language="F#" Value="module DoBindings" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="obj1"> + <MemberSignature Language="C#" Value="public static DoBindings.MyBindingType obj1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property DoBindings/MyBindingType obj1" /> + <MemberSignature Language="F#" Value="DoBindings.obj1 : DoBindings.MyBindingType" Usage="DoBindings.obj1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>DoBindings+MyBindingType</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Enumerations+Color.xml b/mdoc/Test/en.expected-fsharp/Enumerations+Color.xml new file mode 100644 index 00000000..0af49c08 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Enumerations+Color.xml @@ -0,0 +1,71 @@ +<Type Name="Enumerations+Color" FullName="Enumerations+Color"> + <TypeSignature Language="C#" Value="public enum Enumerations.Color" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Enumerations/Color extends System.Enum" /> + <TypeSignature Language="F#" Value="type Enumerations.Color = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Enum</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Blue"> + <MemberSignature Language="C#" Value="Blue" /> + <MemberSignature Language="ILAsm" Value=".field public static literal Enumerations/Color Blue = int32(2)" /> + <MemberSignature Language="F#" Value="Blue = 2" Usage="Enumerations.Color.Blue" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Enumerations+Color</ReturnType> + </ReturnValue> + <MemberValue>2</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + <Member MemberName="Green"> + <MemberSignature Language="C#" Value="Green" /> + <MemberSignature Language="ILAsm" Value=".field public static literal Enumerations/Color Green = int32(1)" /> + <MemberSignature Language="F#" Value="Green = 1" Usage="Enumerations.Color.Green" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Enumerations+Color</ReturnType> + </ReturnValue> + <MemberValue>1</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + <Member MemberName="Red"> + <MemberSignature Language="C#" Value="Red" /> + <MemberSignature Language="ILAsm" Value=".field public static literal Enumerations/Color Red = int32(0)" /> + <MemberSignature Language="F#" Value="Red = 0" Usage="Enumerations.Color.Red" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Enumerations+Color</ReturnType> + </ReturnValue> + <MemberValue>0</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Enumerations.xml b/mdoc/Test/en.expected-fsharp/Enumerations.xml new file mode 100644 index 00000000..e2ad9761 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Enumerations.xml @@ -0,0 +1,46 @@ +<Type Name="Enumerations" FullName="Enumerations"> + <TypeSignature Language="C#" Value="public static class Enumerations" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Enumerations extends System.Object" /> + <TypeSignature Language="F#" Value="module Enumerations" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="col1"> + <MemberSignature Language="C#" Value="public static Enumerations.Color col1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Enumerations/Color col1" /> + <MemberSignature Language="F#" Value="Enumerations.col1 : Enumerations.Color" Usage="Enumerations.col1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Enumerations+Color</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Extensions+MyModule1+MyClass.xml b/mdoc/Test/en.expected-fsharp/Extensions+MyModule1+MyClass.xml new file mode 100644 index 00000000..b9984f59 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Extensions+MyModule1+MyClass.xml @@ -0,0 +1,73 @@ +<Type Name="Extensions+MyModule1+MyClass" FullName="Extensions+MyModule1+MyClass"> + <TypeSignature Language="C#" Value="public class Extensions.MyModule1.MyClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Extensions/MyModule1/MyClass extends System.Object" /> + <TypeSignature Language="F#" Value="type Extensions.MyModule1.MyClass = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="F"> + <MemberSignature Language="C#" Value="public int F ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 F() cil managed" /> + <MemberSignature Language="F#" Value="member this.F : unit -> int" Usage="myClass.F " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="G"> + <MemberSignature Language="C#" Value="public int G ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 G() cil managed" /> + <MemberSignature Language="F#" Value="member this.G : unit -> int" Usage="myClass.G " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Extensions+MyModule1.xml b/mdoc/Test/en.expected-fsharp/Extensions+MyModule1.xml new file mode 100644 index 00000000..36f5796f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Extensions+MyModule1.xml @@ -0,0 +1,23 @@ +<Type Name="Extensions+MyModule1" FullName="Extensions+MyModule1"> + <TypeSignature Language="C#" Value="public static class Extensions.MyModule1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed Extensions/MyModule1 extends System.Object" /> + <TypeSignature Language="F#" Value="module Extensions.MyModule1" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Extensions+MyModule2.xml b/mdoc/Test/en.expected-fsharp/Extensions+MyModule2.xml new file mode 100644 index 00000000..2ff18d05 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Extensions+MyModule2.xml @@ -0,0 +1,44 @@ +<Type Name="Extensions+MyModule2" FullName="Extensions+MyModule2"> + <TypeSignature Language="C#" Value="public static class Extensions.MyModule2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed Extensions/MyModule2 extends System.Object" /> + <TypeSignature Language="F#" Value="module Extensions.MyModule2" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public static void function1 (Extensions.MyModule1.MyClass obj1);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function1(Extensions/MyModule1/MyClass obj1) cil managed" /> + <MemberSignature Language="F#" Value="Extensions.MyModule2.function1 : Extensions.MyModule1.MyClass -> unit" Usage="Extensions.MyModule2.function1 obj1" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj1" Type="Extensions+MyModule1+MyClass" /> + </Parameters> + <Docs> + <param name="obj1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Extensions.xml b/mdoc/Test/en.expected-fsharp/Extensions.xml new file mode 100644 index 00000000..e7759dd6 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Extensions.xml @@ -0,0 +1,72 @@ +<Type Name="Extensions" FullName="Extensions"> + <TypeSignature Language="C#" Value="public static class Extensions" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Extensions extends System.Object" /> + <TypeSignature Language="F#" Value="module Extensions" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Int32.FromString"> + <MemberSignature Language="C#" Value="public static int Int32.FromString (int this, string s);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 Int32.FromString(int32 this, string s) cil managed" /> + <MemberSignature Language="F#" Value="Extensions.Int32.FromString : string -> int" Usage="Extensions.Int32.FromString s" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="this" Type="System.Int32" /> + <Parameter Name="s" Type="System.String" /> + </Parameters> + <Docs> + <param name="this">To be added.</param> + <param name="s">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="testFromString"> + <MemberSignature Language="C#" Value="public static void testFromString (string str);" /> + <MemberSignature Language="ILAsm" Value=".method public static void testFromString(string str) cil managed" /> + <MemberSignature Language="F#" Value="Extensions.testFromString : string -> unit" Usage="Extensions.testFromString str" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="str" Type="System.String" /> + </Parameters> + <Docs> + <param name="str">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/FlexibleTypes.xml b/mdoc/Test/en.expected-fsharp/FlexibleTypes.xml new file mode 100644 index 00000000..620d5e4a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/FlexibleTypes.xml @@ -0,0 +1,128 @@ +<Type Name="FlexibleTypes" FullName="FlexibleTypes"> + <TypeSignature Language="C#" Value="public static class FlexibleTypes" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed FlexibleTypes extends System.Object" /> + <TypeSignature Language="F#" Value="module FlexibleTypes" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="iterate1"> + <MemberSignature Language="C#" Value="public static void iterate1 (Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable<int>> f);" /> + <MemberSignature Language="ILAsm" Value=".method public static void iterate1(class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, class System.Collections.Generic.IEnumerable`1<int32>> f) cil managed" /> + <MemberSignature Language="F#" Value="FlexibleTypes.iterate1 : (unit -> seq<int>) -> unit" Usage="FlexibleTypes.iterate1 f" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="f" Type="Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable<System.Int32>>" /> + </Parameters> + <Docs> + <param name="f">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="iterate2<a>"> + <MemberSignature Language="C#" Value="public static void iterate2<a> (Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,a> f) where a : System.Collections.Generic.IEnumerable<int>;" /> + <MemberSignature Language="ILAsm" Value=".method public static void iterate2<(class System.Collections.Generic.IEnumerable`1<int32>) a>(class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, !!a> f) cil managed" /> + <MemberSignature Language="F#" Value="FlexibleTypes.iterate2 : (unit -> #seq<int>) -> unit" Usage="FlexibleTypes.iterate2 f" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a"> + <Constraints> + <InterfaceName>System.Collections.Generic.IEnumerable<System.Int32></InterfaceName> + </Constraints> + </TypeParameter> + </TypeParameters> + <Parameters> + <Parameter Name="f" Type="Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,a>" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="f">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="iterate3<T>"> + <MemberSignature Language="C#" Value="public static void iterate3<T> (Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,T> f) where T : System.Collections.Generic.IEnumerable<int>;" /> + <MemberSignature Language="ILAsm" Value=".method public static void iterate3<(class System.Collections.Generic.IEnumerable`1<int32>) T>(class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, !!T> f) cil managed" /> + <MemberSignature Language="F#" Value="FlexibleTypes.iterate3 : (unit -> #seq<int>) -> unit" Usage="FlexibleTypes.iterate3 f" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <InterfaceName>System.Collections.Generic.IEnumerable<System.Int32></InterfaceName> + </Constraints> + </TypeParameter> + </TypeParameters> + <Parameters> + <Parameter Name="f" Type="Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,T>" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="f">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="iterate4<T>"> + <MemberSignature Language="C#" Value="public static void iterate4<T> (Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,T> f) where T : Customers.ICustomer;" /> + <MemberSignature Language="ILAsm" Value=".method public static void iterate4<(Customers/ICustomer) T>(class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.Unit, !!T> f) cil managed" /> + <MemberSignature Language="F#" Value="FlexibleTypes.iterate4 : (unit -> 'T (requires 'T :> Customers.ICustomer)) -> unit (requires 'T :> Customers.ICustomer)" Usage="FlexibleTypes.iterate4 f" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T"> + <Constraints> + <InterfaceName>Customers+ICustomer</InterfaceName> + </Constraints> + </TypeParameter> + </TypeParameters> + <Parameters> + <Parameter Name="f" Type="Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.Unit,T>" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="f">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Functions+TestFunction.xml b/mdoc/Test/en.expected-fsharp/Functions+TestFunction.xml new file mode 100644 index 00000000..c0bc0028 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Functions+TestFunction.xml @@ -0,0 +1,54 @@ +<Type Name="Functions+TestFunction" FullName="Functions+TestFunction"> + <TypeSignature Language="C#" Value="public class Functions.TestFunction" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Functions/TestFunction extends System.Object" /> + <TypeSignature Language="F#" Value="type Functions.TestFunction = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public TestFunction ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="f13"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<object,Microsoft.FSharp.Core.Unit> f13 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpFunc`2<object, class Microsoft.FSharp.Core.Unit> f13" /> + <MemberSignature Language="F#" Value="member this.f13 : obj -> unit" Usage="Functions.TestFunction.f13" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Object,Microsoft.FSharp.Core.Unit></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Functions.xml b/mdoc/Test/en.expected-fsharp/Functions.xml new file mode 100644 index 00000000..309e1f8b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Functions.xml @@ -0,0 +1,524 @@ +<Type Name="Functions" FullName="Functions"> + <TypeSignature Language="C#" Value="public static class Functions" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Functions extends System.Object" /> + <TypeSignature Language="F#" Value="module Functions" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="fib"> + <MemberSignature Language="C#" Value="public static int fib (int n);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 fib(int32 n) cil managed" /> + <MemberSignature Language="F#" Value="Functions.fib : int -> int" Usage="Functions.fib n" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="n" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="n">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public static int function1 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function1(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function1 : int -> int" Usage="Functions.function1 x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function10<a>"> + <MemberSignature Language="C#" Value="public static void function10<a> (object x, object y, object z, object a);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function10<a>(object x, object y, object z, object a) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function10 : obj * obj -> obj * obj -> unit" Usage="Functions.function10 (x, y) (z, a)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="x" Type="System.Object" /> + <Parameter Name="y" Type="System.Object" /> + <Parameter Name="z" Type="System.Object" /> + <Parameter Name="a" Type="System.Object" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="z">To be added.</param> + <param name="a">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function11<a>"> + <MemberSignature Language="C#" Value="public static void function11<a> (object x, object y, object z, object a, object b);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function11<a>(object x, object y, object z, object a, object b) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function11 : obj * obj * obj -> obj * obj -> unit" Usage="Functions.function11 (x, y, z) (a, b)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="x" Type="System.Object" /> + <Parameter Name="y" Type="System.Object" /> + <Parameter Name="z" Type="System.Object" /> + <Parameter Name="a" Type="System.Object" /> + <Parameter Name="b" Type="System.Object" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="z">To be added.</param> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function12<a>"> + <MemberSignature Language="C#" Value="public static void function12<a> (object x, object a, object b, object c, object d, object e);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function12<a>(object x, object a, object b, object c, object d, object e) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function12 : obj -> obj * obj * obj * obj * obj -> unit" Usage="Functions.function12 x (a, b, c, d, e)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="x" Type="System.Object" /> + <Parameter Name="a" Type="System.Object" /> + <Parameter Name="b" Type="System.Object" /> + <Parameter Name="c" Type="System.Object" /> + <Parameter Name="d" Type="System.Object" /> + <Parameter Name="e" Type="System.Object" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="x">To be added.</param> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <param name="d">To be added.</param> + <param name="e">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function13<a>"> + <MemberSignature Language="C#" Value="public static void function13<a> (a a);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function13<a>(!!a a) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function13 : 'a -> unit" Usage="Functions.function13 a" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="a" Type="a" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="a">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function2"> + <MemberSignature Language="C#" Value="public static int function2 (int x2);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function2(int32 x2) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function2 : int -> int" Usage="Functions.function2 x2" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x2" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function3"> + <MemberSignature Language="C#" Value="public static int function3 (int x3);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function3(int32 x3) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function3 : int -> int" Usage="Functions.function3 x3" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x3" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x3">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function4"> + <MemberSignature Language="C#" Value="public static int function4 (int x4, int y4);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function4(int32 x4, int32 y4) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function4 : int -> int -> int" Usage="Functions.function4 x4 y4" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x4" Type="System.Int32" /> + <Parameter Name="y4" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x4">To be added.</param> + <param name="y4">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function5"> + <MemberSignature Language="C#" Value="public static int function5 (int x5, int y5);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 function5(int32 x5, int32 y5) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function5 : int * int -> int" Usage="Functions.function5 (x5, y5)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x5" Type="System.Int32" /> + <Parameter Name="y5" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x5">To be added.</param> + <param name="y5">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function6<a,b>"> + <MemberSignature Language="C#" Value="public static void function6<a,b> (a x6, b y6);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function6<a, b>(!!a x6, !!b y6) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function6 : 'a * 'b -> unit" Usage="Functions.function6 (x6, y6)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + <TypeParameter Name="b" /> + </TypeParameters> + <Parameters> + <Parameter Name="x6" Type="a" /> + <Parameter Name="y6" Type="b" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <typeparam name="b">To be added.</typeparam> + <param name="x6">To be added.</param> + <param name="y6">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function7<a,b,c>"> + <MemberSignature Language="C#" Value="public static void function7<a,b,c> (a x7, b y7, c z7);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function7<a, b, c>(!!a x7, !!b y7, !!c z7) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function7 : 'a -> 'b * 'c -> unit" Usage="Functions.function7 x7 (y7, z7)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + <TypeParameter Name="b" /> + <TypeParameter Name="c" /> + </TypeParameters> + <Parameters> + <Parameter Name="x7" Type="a" /> + <Parameter Name="y7" Type="b" /> + <Parameter Name="z7" Type="c" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <typeparam name="b">To be added.</typeparam> + <typeparam name="c">To be added.</typeparam> + <param name="x7">To be added.</param> + <param name="y7">To be added.</param> + <param name="z7">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function8<a,b,c>"> + <MemberSignature Language="C#" Value="public static void function8<a,b,c> (a x8, b y8, c z8);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function8<a, b, c>(!!a x8, !!b y8, !!c z8) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function8 : 'a -> 'b -> 'c -> unit" Usage="Functions.function8 x8 y8 z8" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + <TypeParameter Name="b" /> + <TypeParameter Name="c" /> + </TypeParameters> + <Parameters> + <Parameter Name="x8" Type="a" /> + <Parameter Name="y8" Type="b" /> + <Parameter Name="z8" Type="c" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <typeparam name="b">To be added.</typeparam> + <typeparam name="c">To be added.</typeparam> + <param name="x8">To be added.</param> + <param name="y8">To be added.</param> + <param name="z8">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function9<a,b,c,d>"> + <MemberSignature Language="C#" Value="public static void function9<a,b,c,d> (a x9, b y9, c z9, d a9);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function9<a, b, c, d>(!!a x9, !!b y9, !!c z9, !!d a9) cil managed" /> + <MemberSignature Language="F#" Value="Functions.function9 : 'a * 'b -> 'c * 'd -> unit" Usage="Functions.function9 (x9, y9) (z9, a9)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + <TypeParameter Name="b" /> + <TypeParameter Name="c" /> + <TypeParameter Name="d" /> + </TypeParameters> + <Parameters> + <Parameter Name="x9" Type="a" /> + <Parameter Name="y9" Type="b" /> + <Parameter Name="z9" Type="c" /> + <Parameter Name="a9" Type="d" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <typeparam name="b">To be added.</typeparam> + <typeparam name="c">To be added.</typeparam> + <typeparam name="d">To be added.</typeparam> + <param name="x9">To be added.</param> + <param name="y9">To be added.</param> + <param name="z9">To be added.</param> + <param name="a9">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="h"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<int,int> h { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<int32, int32> h" /> + <MemberSignature Language="F#" Value="Functions.h : int -> int" Usage="Functions.h" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Int32,System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="publicLet"> + <MemberSignature Language="C#" Value="public static int publicLet (int n);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 publicLet(int32 n) cil managed" /> + <MemberSignature Language="F#" Value="Functions.publicLet : int -> int" Usage="Functions.publicLet n" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="n" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="n">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="result"> + <MemberSignature Language="C#" Value="public static int result { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 result" /> + <MemberSignature Language="F#" Value="Functions.result : int" Usage="Functions.result" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="result5"> + <MemberSignature Language="C#" Value="public static int result5 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 result5" /> + <MemberSignature Language="F#" Value="Functions.result5 : int" Usage="Functions.result5" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Generics+Map2`2.xml b/mdoc/Test/en.expected-fsharp/Generics+Map2`2.xml new file mode 100644 index 00000000..8595779a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Generics+Map2`2.xml @@ -0,0 +1,147 @@ +<Type Name="Generics+Map2<Key,Value>" FullName="Generics+Map2<Key,Value>"> + <TypeSignature Language="C#" Value="public class Generics.Map2<Key,Value>" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit Generics/Map2`2<Key, Value> extends System.Object" /> + <TypeSignature Language="F#" Value="type Generics.Map2<'Key, 'Value> = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <TypeParameters> + <TypeParameter Name="Key"> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.EqualityConditionalOn</AttributeName> + </Attribute> + </Attributes> + </TypeParameter> + <TypeParameter Name="Value"> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.ComparisonConditionalOn</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.EqualityConditionalOn</AttributeName> + </Attribute> + </Attributes> + </TypeParameter> + </TypeParameters> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <typeparam name="Key">To be added.</typeparam> + <typeparam name="Value">To be added.</typeparam> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="c"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpChoice<int,double> c { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpChoice`2<int32, float64> c" /> + <MemberSignature Language="F#" Value="member this.c : Choice<int, double>" Usage="Generics.Map2<'Key, 'Value>.c" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpChoice<System.Int32,System.Double></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="c2"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpChoice<int,double> c2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpChoice`2<int32, float64> c2" /> + <MemberSignature Language="F#" Value="member this.c2 : Choice<int, double>" Usage="Generics.Map2<'Key, 'Value>.c2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpChoice<System.Int32,System.Double></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="fffff"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpOption<int> fffff { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpOption`1<int32> fffff" /> + <MemberSignature Language="F#" Value="member this.fffff : option<int>" Usage="Generics.Map2<'Key, 'Value>.fffff" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpOption<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="l"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Collections.FSharpList<int> l { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Collections.FSharpList`1<int32> l" /> + <MemberSignature Language="F#" Value="member this.l : List<int>" Usage="Generics.Map2<'Key, 'Value>.l" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Collections.FSharpList<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="r"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpRef<int> r { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpRef`1<int32> r" /> + <MemberSignature Language="F#" Value="member this.r : ref<int>" Usage="Generics.Map2<'Key, 'Value>.r" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpRef<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="s"> + <MemberSignature Language="C#" Value="public System.Collections.Generic.IEnumerable<int> s { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Generic.IEnumerable`1<int32> s" /> + <MemberSignature Language="F#" Value="member this.s : seq<int>" Usage="Generics.Map2<'Key, 'Value>.s" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Collections.Generic.IEnumerable<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Generics.xml b/mdoc/Test/en.expected-fsharp/Generics.xml new file mode 100644 index 00000000..61fca831 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Generics.xml @@ -0,0 +1,118 @@ +<Type Name="Generics" FullName="Generics"> + <TypeSignature Language="C#" Value="public static class Generics" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Generics extends System.Object" /> + <TypeSignature Language="F#" Value="module Generics" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="function1<a>"> + <MemberSignature Language="C#" Value="public static void function1<a> (a x, a y);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function1<a>(!!a x, !!a y) cil managed" /> + <MemberSignature Language="F#" Value="Generics.function1 : 'a -> 'a -> unit" Usage="Generics.function1 x y" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="x" Type="a" /> + <Parameter Name="y" Type="a" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function2<T>"> + <MemberSignature Language="C#" Value="public static void function2<T> (object x, object y);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function2<T>(object x, object y) cil managed" /> + <MemberSignature Language="F#" Value="Generics.function2 : obj -> obj -> unit" Usage="Generics.function2 x y" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Parameters> + <Parameter Name="x" Type="System.Object" /> + <Parameter Name="y" Type="System.Object" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="makeList<a>"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Collections.FSharpList<a> makeList<a> (a a, a b);" /> + <MemberSignature Language="ILAsm" Value=".method public static class Microsoft.FSharp.Collections.FSharpList`1<!!a> makeList<a>(!!a a, !!a b) cil managed" /> + <MemberSignature Language="F#" Value="Generics.makeList : 'a -> 'a -> List<'a>" Usage="Generics.makeList a b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Collections.FSharpList<a></ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="a" Type="a" /> + <Parameter Name="b" Type="a" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/IndexedProperties+NumberStrings.xml b/mdoc/Test/en.expected-fsharp/IndexedProperties+NumberStrings.xml new file mode 100644 index 00000000..76ea45bd --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/IndexedProperties+NumberStrings.xml @@ -0,0 +1,100 @@ +<Type Name="IndexedProperties+NumberStrings" FullName="IndexedProperties+NumberStrings"> + <TypeSignature Language="C#" Value="public class IndexedProperties.NumberStrings" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable IndexedProperties/NumberStrings extends System.Object" /> + <TypeSignature Language="F#" Value="type IndexedProperties.NumberStrings = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public NumberStrings ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Cardinal"> + <MemberSignature Language="C#" Value="public string Cardinal[int index] { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Cardinal(int32)" /> + <MemberSignature Language="F#" Value="member this.Cardinal(int) : string with get, set" Usage="IndexedProperties.NumberStrings.Cardinal" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="index" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="index">To be added.</param> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Item"> + <MemberSignature Language="C#" Value="public string this[int index] { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Item(int32)" /> + <MemberSignature Language="F#" Value="member this.Item(int) : string with get, set" Usage="IndexedProperties.NumberStrings.Item" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="index" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="index">To be added.</param> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Ordinal"> + <MemberSignature Language="C#" Value="public string Ordinal[int index] { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Ordinal(int32)" /> + <MemberSignature Language="F#" Value="member this.Ordinal(int) : string with get, set" Usage="IndexedProperties.NumberStrings.Ordinal" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="index" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="index">To be added.</param> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/IndexedProperties.xml b/mdoc/Test/en.expected-fsharp/IndexedProperties.xml new file mode 100644 index 00000000..8f05cbcb --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/IndexedProperties.xml @@ -0,0 +1,46 @@ +<Type Name="IndexedProperties" FullName="IndexedProperties"> + <TypeSignature Language="C#" Value="public static class IndexedProperties" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed IndexedProperties extends System.Object" /> + <TypeSignature Language="F#" Value="module IndexedProperties" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="nstrs"> + <MemberSignature Language="C#" Value="public static IndexedProperties.NumberStrings nstrs { get; }" /> + <MemberSignature Language="ILAsm" Value=".property IndexedProperties/NumberStrings nstrs" /> + <MemberSignature Language="F#" Value="IndexedProperties.nstrs : IndexedProperties.NumberStrings" Usage="IndexedProperties.nstrs" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>IndexedProperties+NumberStrings</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance+BaseClass.xml b/mdoc/Test/en.expected-fsharp/Inheritance+BaseClass.xml new file mode 100644 index 00000000..5c7c1fa7 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance+BaseClass.xml @@ -0,0 +1,76 @@ +<Type Name="Inheritance+BaseClass" FullName="Inheritance+BaseClass"> + <TypeSignature Language="C#" Value="public class Inheritance.BaseClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Inheritance/BaseClass extends System.Object" /> + <TypeSignature Language="F#" Value="type Inheritance.BaseClass = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public BaseClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public BaseClass (string str);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string str) cil managed" /> + <MemberSignature Language="F#" Value="new Inheritance.BaseClass : string -> Inheritance.BaseClass" Usage="new Inheritance.BaseClass str" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="str" Type="System.String" /> + </Parameters> + <Docs> + <param name="str">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="string1"> + <MemberSignature Language="C#" Value="public string string1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string string1" /> + <MemberSignature Language="F#" Value="val string1 : string" Usage="Inheritance.BaseClass.string1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance+DerivedClass.xml b/mdoc/Test/en.expected-fsharp/Inheritance+DerivedClass.xml new file mode 100644 index 00000000..086a06ef --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance+DerivedClass.xml @@ -0,0 +1,82 @@ +<Type Name="Inheritance+DerivedClass" FullName="Inheritance+DerivedClass"> + <TypeSignature Language="C#" Value="public class Inheritance.DerivedClass : Inheritance.BaseClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Inheritance/DerivedClass extends tance/BaseClass" /> + <TypeSignature Language="F#" Value="type Inheritance.DerivedClass = class
 inherit Inheritance.BaseClass" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Inheritance+BaseClass</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public DerivedClass (string str2);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string str2) cil managed" /> + <MemberSignature Language="F#" Value="new Inheritance.DerivedClass : string -> Inheritance.DerivedClass" Usage="new Inheritance.DerivedClass str2" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="str2" Type="System.String" /> + </Parameters> + <Docs> + <param name="str2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public DerivedClass (string str1, string str2);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string str1, string str2) cil managed" /> + <MemberSignature Language="F#" Value="new Inheritance.DerivedClass : string * string -> Inheritance.DerivedClass" Usage="new Inheritance.DerivedClass (str1, str2)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="str1" Type="System.String" /> + <Parameter Name="str2" Type="System.String" /> + </Parameters> + <Docs> + <param name="str1">To be added.</param> + <param name="str2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="string2"> + <MemberSignature Language="C#" Value="public string string2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string string2" /> + <MemberSignature Language="F#" Value="val string2 : string" Usage="Inheritance.DerivedClass.string2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance+MyClassBase1.xml b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassBase1.xml new file mode 100644 index 00000000..31700810 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassBase1.xml @@ -0,0 +1,58 @@ +<Type Name="Inheritance+MyClassBase1" FullName="Inheritance+MyClassBase1"> + <TypeSignature Language="C#" Value="public class Inheritance.MyClassBase1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Inheritance/MyClassBase1 extends System.Object" /> + <TypeSignature Language="F#" Value="type Inheritance.MyClassBase1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassBase1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public override int function1 (int a);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 function1(int32 a) cil managed" /> + <MemberSignature Language="F#" Value="abstract member function1 : int -> int
override this.function1 : int -> int" Usage="myClassBase1.function1 a" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance+MyClassBase2.xml b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassBase2.xml new file mode 100644 index 00000000..6e0ac56a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassBase2.xml @@ -0,0 +1,41 @@ +<Type Name="Inheritance+MyClassBase2" FullName="Inheritance+MyClassBase2"> + <TypeSignature Language="C#" Value="public class Inheritance.MyClassBase2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Inheritance/MyClassBase2 extends System.Object" /> + <TypeSignature Language="F#" Value="type Inheritance.MyClassBase2 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassBase2 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="new Inheritance.MyClassBase2 : int -> Inheritance.MyClassBase2" Usage="new Inheritance.MyClassBase2 x" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance+MyClassDerived1.xml b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassDerived1.xml new file mode 100644 index 00000000..c017542a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassDerived1.xml @@ -0,0 +1,58 @@ +<Type Name="Inheritance+MyClassDerived1" FullName="Inheritance+MyClassDerived1"> + <TypeSignature Language="C#" Value="public class Inheritance.MyClassDerived1 : Inheritance.MyClassBase1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Inheritance/MyClassDerived1 extends tance/MyClassBase1" /> + <TypeSignature Language="F#" Value="type Inheritance.MyClassDerived1 = class
 inherit Inheritance.MyClassBase1" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Inheritance+MyClassBase1</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassDerived1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public override int function1 (int a);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 function1(int32 a) cil managed" /> + <MemberSignature Language="F#" Value="override this.function1 : int -> int" Usage="myClassDerived1.function1 a" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance+MyClassDerived2.xml b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassDerived2.xml new file mode 100644 index 00000000..aad8bc6a --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance+MyClassDerived2.xml @@ -0,0 +1,41 @@ +<Type Name="Inheritance+MyClassDerived2" FullName="Inheritance+MyClassDerived2"> + <TypeSignature Language="C#" Value="public class Inheritance.MyClassDerived2 : Inheritance.MyClassBase2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Inheritance/MyClassDerived2 extends tance/MyClassBase2" /> + <TypeSignature Language="F#" Value="type Inheritance.MyClassDerived2 = class
 inherit Inheritance.MyClassBase2" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Inheritance+MyClassBase2</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClassDerived2 (int y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 y) cil managed" /> + <MemberSignature Language="F#" Value="new Inheritance.MyClassDerived2 : int -> Inheritance.MyClassDerived2" Usage="new Inheritance.MyClassDerived2 y" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="y" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Inheritance.xml b/mdoc/Test/en.expected-fsharp/Inheritance.xml new file mode 100644 index 00000000..1563d64b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Inheritance.xml @@ -0,0 +1,68 @@ +<Type Name="Inheritance" FullName="Inheritance"> + <TypeSignature Language="C#" Value="public static class Inheritance" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Inheritance extends System.Object" /> + <TypeSignature Language="F#" Value="module Inheritance" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="obj1"> + <MemberSignature Language="C#" Value="public static Inheritance.DerivedClass obj1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Inheritance/DerivedClass obj1" /> + <MemberSignature Language="F#" Value="Inheritance.obj1 : Inheritance.DerivedClass" Usage="Inheritance.obj1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Inheritance+DerivedClass</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="obj2"> + <MemberSignature Language="C#" Value="public static Inheritance.DerivedClass obj2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Inheritance/DerivedClass obj2" /> + <MemberSignature Language="F#" Value="Inheritance.obj2 : Inheritance.DerivedClass" Usage="Inheritance.obj2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Inheritance+DerivedClass</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/InlineFunctions+WrapInt32.xml b/mdoc/Test/en.expected-fsharp/InlineFunctions+WrapInt32.xml new file mode 100644 index 00000000..b3aa7dbe --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/InlineFunctions+WrapInt32.xml @@ -0,0 +1,79 @@ +<Type Name="InlineFunctions+WrapInt32" FullName="InlineFunctions+WrapInt32"> + <TypeSignature Language="C#" Value="public class InlineFunctions.WrapInt32" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable InlineFunctions/WrapInt32 extends System.Object" /> + <TypeSignature Language="F#" Value="type InlineFunctions.WrapInt32 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public WrapInt32 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Increment"> + <MemberSignature Language="C#" Value="public static int Increment (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 Increment(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="static member Increment : int -> int" Usage="InlineFunctions.WrapInt32.Increment x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="incrementByOne"> + <MemberSignature Language="C#" Value="public int incrementByOne (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 incrementByOne(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="member this.incrementByOne : int -> int" Usage="wrapInt32.incrementByOne x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/InlineFunctions.xml b/mdoc/Test/en.expected-fsharp/InlineFunctions.xml new file mode 100644 index 00000000..f7a6dcc0 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/InlineFunctions.xml @@ -0,0 +1,69 @@ +<Type Name="InlineFunctions" FullName="InlineFunctions"> + <TypeSignature Language="C#" Value="public static class InlineFunctions" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed InlineFunctions extends System.Object" /> + <TypeSignature Language="F#" Value="module InlineFunctions" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="increment"> + <MemberSignature Language="C#" Value="public static int increment (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 increment(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="InlineFunctions.increment : int -> int" Usage="InlineFunctions.increment x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="printAsFloatingPoint<a>"> + <MemberSignature Language="C#" Value="public static void printAsFloatingPoint<a> (a number);" /> + <MemberSignature Language="ILAsm" Value=".method public static void printAsFloatingPoint<a>(!!a number) cil managed" /> + <MemberSignature Language="F#" Value="InlineFunctions.printAsFloatingPoint : 'a -> unit" Usage="InlineFunctions.printAsFloatingPoint number" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="number" Type="a" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="number">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+IPrintable.xml b/mdoc/Test/en.expected-fsharp/Interfaces+IPrintable.xml new file mode 100644 index 00000000..009dc8ed --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+IPrintable.xml @@ -0,0 +1,38 @@ +<Type Name="Interfaces+IPrintable" FullName="Interfaces+IPrintable"> + <TypeSignature Language="C#" Value="public interface Interfaces.IPrintable" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable Interfaces/IPrintable" /> + <TypeSignature Language="F#" Value="type Interfaces.IPrintable = interface" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Print"> + <MemberSignature Language="C#" Value="public void Print ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Print() cil managed" /> + <MemberSignature Language="F#" Value="abstract member Print : unit -> unit" Usage="iPrintable.Print " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+Interface0.xml b/mdoc/Test/en.expected-fsharp/Interfaces+Interface0.xml new file mode 100644 index 00000000..556071d8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+Interface0.xml @@ -0,0 +1,42 @@ +<Type Name="Interfaces+Interface0" FullName="Interfaces+Interface0"> + <TypeSignature Language="C#" Value="public interface Interfaces.Interface0" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable Interfaces/Interface0" /> + <TypeSignature Language="F#" Value="type Interfaces.Interface0 = interface" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Method1"> + <MemberSignature Language="C#" Value="public int Method1 (int );" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 Method1(int32 ) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Method1 : int -> int" Usage="interface0.Method1 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+Interface1.xml b/mdoc/Test/en.expected-fsharp/Interfaces+Interface1.xml new file mode 100644 index 00000000..2b3dd4a3 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+Interface1.xml @@ -0,0 +1,42 @@ +<Type Name="Interfaces+Interface1" FullName="Interfaces+Interface1"> + <TypeSignature Language="C#" Value="public interface Interfaces.Interface1" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable Interfaces/Interface1" /> + <TypeSignature Language="F#" Value="type Interfaces.Interface1 = interface" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Method1"> + <MemberSignature Language="C#" Value="public int Method1 (int );" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 Method1(int32 ) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Method1 : int -> int" Usage="interface1.Method1 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+Interface2.xml b/mdoc/Test/en.expected-fsharp/Interfaces+Interface2.xml new file mode 100644 index 00000000..a53a6ff6 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+Interface2.xml @@ -0,0 +1,42 @@ +<Type Name="Interfaces+Interface2" FullName="Interfaces+Interface2"> + <TypeSignature Language="C#" Value="public interface Interfaces.Interface2" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable Interfaces/Interface2" /> + <TypeSignature Language="F#" Value="type Interfaces.Interface2 = interface" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Method2"> + <MemberSignature Language="C#" Value="public int Method2 (int );" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 Method2(int32 ) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Method2 : int -> int" Usage="interface2.Method2 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+Interface3.xml b/mdoc/Test/en.expected-fsharp/Interfaces+Interface3.xml new file mode 100644 index 00000000..eecd70cf --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+Interface3.xml @@ -0,0 +1,49 @@ +<Type Name="Interfaces+Interface3" FullName="Interfaces+Interface3"> + <TypeSignature Language="C#" Value="public interface Interfaces.Interface3 : Interfaces.Interface1, Interfaces.Interface2" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable Interfaces/Interface3 implements Interfaces/Interface1, Interfaces/Interface2" /> + <TypeSignature Language="F#" Value="type Interfaces.Interface3 = interface
 interface Interfaces.Interface2
 interface Interfaces.Interface1" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces> + <Interface> + <InterfaceName>Interfaces+Interface1</InterfaceName> + </Interface> + <Interface> + <InterfaceName>Interfaces+Interface2</InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Method3"> + <MemberSignature Language="C#" Value="public int Method3 (int );" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 Method3(int32 ) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Method3 : int -> int" Usage="interface3.Method3 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+MyClass.xml b/mdoc/Test/en.expected-fsharp/Interfaces+MyClass.xml new file mode 100644 index 00000000..a0b4dab8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+MyClass.xml @@ -0,0 +1,41 @@ +<Type Name="Interfaces+MyClass" FullName="Interfaces+MyClass"> + <TypeSignature Language="C#" Value="public class Interfaces.MyClass : Interfaces.Interface3" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Interfaces/MyClass extends System.Object implements Interfaces/Interface3" /> + <TypeSignature Language="F#" Value="type Interfaces.MyClass = class
 interface Interfaces.Interface3" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>Interfaces+Interface3</InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+SomeClass1.xml b/mdoc/Test/en.expected-fsharp/Interfaces+SomeClass1.xml new file mode 100644 index 00000000..a411e447 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+SomeClass1.xml @@ -0,0 +1,47 @@ +<Type Name="Interfaces+SomeClass1" FullName="Interfaces+SomeClass1"> + <TypeSignature Language="C#" Value="public class Interfaces.SomeClass1 : Interfaces.IPrintable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Interfaces/SomeClass1 extends System.Object implements Interfaces/IPrintable" /> + <TypeSignature Language="F#" Value="type Interfaces.SomeClass1 = class
 interface Interfaces.IPrintable" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>Interfaces+IPrintable</InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public SomeClass1 (int x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new Interfaces.SomeClass1 : int * double -> Interfaces.SomeClass1" Usage="new Interfaces.SomeClass1 (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces+SomeClass2.xml b/mdoc/Test/en.expected-fsharp/Interfaces+SomeClass2.xml new file mode 100644 index 00000000..d3dbc25c --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces+SomeClass2.xml @@ -0,0 +1,64 @@ +<Type Name="Interfaces+SomeClass2" FullName="Interfaces+SomeClass2"> + <TypeSignature Language="C#" Value="public class Interfaces.SomeClass2 : Interfaces.IPrintable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Interfaces/SomeClass2 extends System.Object implements Interfaces/IPrintable" /> + <TypeSignature Language="F#" Value="type Interfaces.SomeClass2 = class
 interface Interfaces.IPrintable" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>Interfaces+IPrintable</InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public SomeClass2 (int x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new Interfaces.SomeClass2 : int * double -> Interfaces.SomeClass2" Usage="new Interfaces.SomeClass2 (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Print"> + <MemberSignature Language="C#" Value="public void Print ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Print() cil managed" /> + <MemberSignature Language="F#" Value="member this.Print : unit -> unit" Usage="someClass2.Print " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Interfaces.xml b/mdoc/Test/en.expected-fsharp/Interfaces.xml new file mode 100644 index 00000000..9718481f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Interfaces.xml @@ -0,0 +1,68 @@ +<Type Name="Interfaces" FullName="Interfaces"> + <TypeSignature Language="C#" Value="public static class Interfaces" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Interfaces extends System.Object" /> + <TypeSignature Language="F#" Value="module Interfaces" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="x1"> + <MemberSignature Language="C#" Value="public static Interfaces.SomeClass1 x1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Interfaces/SomeClass1 x1" /> + <MemberSignature Language="F#" Value="Interfaces.x1 : Interfaces.SomeClass1" Usage="Interfaces.x1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Interfaces+SomeClass1</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x2"> + <MemberSignature Language="C#" Value="public static Interfaces.SomeClass2 x2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Interfaces/SomeClass2 x2" /> + <MemberSignature Language="F#" Value="Interfaces.x2 : Interfaces.SomeClass2" Usage="Interfaces.x2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Interfaces+SomeClass2</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Literals.xml b/mdoc/Test/en.expected-fsharp/Literals.xml new file mode 100644 index 00000000..11d277e6 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Literals.xml @@ -0,0 +1,254 @@ +<Type Name="Literals" FullName="Literals"> + <TypeSignature Language="C#" Value="public static class Literals" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Literals extends System.Object" /> + <TypeSignature Language="F#" Value="module Literals" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="FileLocation"> + <MemberSignature Language="C#" Value="public const string FileLocation;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal string FileLocation" /> + <MemberSignature Language="F#" Value="val mutable FileLocation : string" Usage="Literals.FileLocation" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Literal</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Literal1"> + <MemberSignature Language="C#" Value="public const string Literal1;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal string Literal1" /> + <MemberSignature Language="F#" Value="val mutable Literal1 : string" Usage="Literals.Literal1" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Literal</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Literal2"> + <MemberSignature Language="C#" Value="public const int Literal2 = 65;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Literal2 = (65)" /> + <MemberSignature Language="F#" Value="val mutable Literal2 : int" Usage="Literals.Literal2" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Literal</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>65</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Literal3"> + <MemberSignature Language="C#" Value="public const System.IO.FileAccess Literal3 = 3;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal valuetype System.IO.FileAccess Literal3 = (3)" /> + <MemberSignature Language="F#" Value="val mutable Literal3 : System.IO.FileAccess" Usage="Literals.Literal3" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Literal</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.IO.FileAccess</ReturnType> + </ReturnValue> + <MemberValue>3</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="someBigint"> + <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger someBigint { get; }" /> + <MemberSignature Language="ILAsm" Value=".property valuetype System.Numerics.BigInteger someBigint" /> + <MemberSignature Language="F#" Value="Literals.someBigint : System.Numerics.BigInteger" Usage="Literals.someBigint" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Numerics.BigInteger</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="someByte"> + <MemberSignature Language="C#" Value="public static byte someByte { get; }" /> + <MemberSignature Language="ILAsm" Value=".property unsigned int8 someByte" /> + <MemberSignature Language="F#" Value="Literals.someByte : byte" Usage="Literals.someByte" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Byte</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="someChar"> + <MemberSignature Language="C#" Value="public static char someChar { get; }" /> + <MemberSignature Language="ILAsm" Value=".property char someChar" /> + <MemberSignature Language="F#" Value="Literals.someChar : char" Usage="Literals.someChar" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Char</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="someDecimal"> + <MemberSignature Language="C#" Value="public static decimal someDecimal { get; }" /> + <MemberSignature Language="ILAsm" Value=".property valuetype System.Decimal someDecimal" /> + <MemberSignature Language="F#" Value="Literals.someDecimal : decimal" Usage="Literals.someDecimal" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Decimal</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="someSbyte"> + <MemberSignature Language="C#" Value="public static sbyte someSbyte { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int8 someSbyte" /> + <MemberSignature Language="F#" Value="Literals.someSbyte : sbyte" Usage="Literals.someSbyte" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.SByte</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="someString"> + <MemberSignature Language="C#" Value="public static string someString { get; }" /> + <MemberSignature Language="ILAsm" Value=".property string someString" /> + <MemberSignature Language="F#" Value="Literals.someString : string" Usage="Literals.someString" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Methods+Circle.xml b/mdoc/Test/en.expected-fsharp/Methods+Circle.xml new file mode 100644 index 00000000..522a27d1 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Methods+Circle.xml @@ -0,0 +1,61 @@ +<Type Name="Methods+Circle" FullName="Methods+Circle"> + <TypeSignature Language="C#" Value="public class Methods.Circle : Methods.Ellipse" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Methods/Circle extends s/Ellipse" /> + <TypeSignature Language="F#" Value="type Methods.Circle = class
 inherit Methods.Ellipse" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>Methods+Ellipse</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Circle (double radius);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 radius) cil managed" /> + <MemberSignature Language="F#" Value="new Methods.Circle : double -> Methods.Circle" Usage="new Methods.Circle radius" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="radius" Type="System.Double" /> + </Parameters> + <Docs> + <param name="radius">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate"> + <MemberSignature Language="C#" Value="public override void Rotate (double _arg1);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate(float64 _arg1) cil managed" /> + <MemberSignature Language="F#" Value="override this.Rotate : double -> unit" Usage="circle.Rotate _arg1" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_arg1" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_arg1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Methods+Ellipse.xml b/mdoc/Test/en.expected-fsharp/Methods+Ellipse.xml new file mode 100644 index 00000000..9b8ee949 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Methods+Ellipse.xml @@ -0,0 +1,65 @@ +<Type Name="Methods+Ellipse" FullName="Methods+Ellipse"> + <TypeSignature Language="C#" Value="public class Methods.Ellipse" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Methods/Ellipse extends System.Object" /> + <TypeSignature Language="F#" Value="type Methods.Ellipse = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Ellipse (double a0, double b0, double theta0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 a0, float64 b0, float64 theta0) cil managed" /> + <MemberSignature Language="F#" Value="new Methods.Ellipse : double * double * double -> Methods.Ellipse" Usage="new Methods.Ellipse (a0, b0, theta0)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="a0" Type="System.Double" /> + <Parameter Name="b0" Type="System.Double" /> + <Parameter Name="theta0" Type="System.Double" /> + </Parameters> + <Docs> + <param name="a0">To be added.</param> + <param name="b0">To be added.</param> + <param name="theta0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rotate"> + <MemberSignature Language="C#" Value="public override void Rotate (double delta);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Rotate(float64 delta) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Rotate : double -> unit
override this.Rotate : double -> unit" Usage="ellipse.Rotate delta" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="delta" Type="System.Double" /> + </Parameters> + <Docs> + <param name="delta">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Methods+RectangleXY.xml b/mdoc/Test/en.expected-fsharp/Methods+RectangleXY.xml new file mode 100644 index 00000000..9098bf8b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Methods+RectangleXY.xml @@ -0,0 +1,138 @@ +<Type Name="Methods+RectangleXY" FullName="Methods+RectangleXY"> + <TypeSignature Language="C#" Value="public class Methods.RectangleXY" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Methods/RectangleXY extends System.Object" /> + <TypeSignature Language="F#" Value="type Methods.RectangleXY = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public RectangleXY (double x1, double y1, double x2, double y2);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x1, float64 y1, float64 x2, float64 y2) cil managed" /> + <MemberSignature Language="F#" Value="new Methods.RectangleXY : double * double * double * double -> Methods.RectangleXY" Usage="new Methods.RectangleXY (x1, y1, x2, y2)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x1" Type="System.Double" /> + <Parameter Name="y1" Type="System.Double" /> + <Parameter Name="x2" Type="System.Double" /> + <Parameter Name="y2" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x1">To be added.</param> + <param name="y1">To be added.</param> + <param name="x2">To be added.</param> + <param name="y2">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="intersection"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpOption<Methods.RectangleXY> intersection (Methods.RectangleXY rect1, Methods.RectangleXY rect2);" /> + <MemberSignature Language="ILAsm" Value=".method public static class Microsoft.FSharp.Core.FSharpOption`1<Methods/RectangleXY> intersection(Methods/RectangleXY rect1, Methods/RectangleXY rect2) cil managed" /> + <MemberSignature Language="F#" Value="static member intersection : Methods.RectangleXY * Methods.RectangleXY -> option<Methods.RectangleXY>" Usage="Methods.RectangleXY.intersection (rect1, rect2)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpOption<Methods+RectangleXY></ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="rect1" Type="Methods+RectangleXY" /> + <Parameter Name="rect2" Type="Methods+RectangleXY" /> + </Parameters> + <Docs> + <param name="rect1">To be added.</param> + <param name="rect2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X1"> + <MemberSignature Language="C#" Value="public double X1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 X1" /> + <MemberSignature Language="F#" Value="member this.X1 : double" Usage="Methods.RectangleXY.X1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X2"> + <MemberSignature Language="C#" Value="public double X2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 X2" /> + <MemberSignature Language="F#" Value="member this.X2 : double" Usage="Methods.RectangleXY.X2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y1"> + <MemberSignature Language="C#" Value="public double Y1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Y1" /> + <MemberSignature Language="F#" Value="member this.Y1 : double" Usage="Methods.RectangleXY.Y1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y2"> + <MemberSignature Language="C#" Value="public double Y2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Y2" /> + <MemberSignature Language="F#" Value="member this.Y2 : double" Usage="Methods.RectangleXY.Y2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Methods+SomeType.xml b/mdoc/Test/en.expected-fsharp/Methods+SomeType.xml new file mode 100644 index 00000000..72165425 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Methods+SomeType.xml @@ -0,0 +1,294 @@ +<Type Name="Methods+SomeType" FullName="Methods+SomeType"> + <TypeSignature Language="C#" Value="public class Methods.SomeType" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Methods/SomeType extends System.Object" /> + <TypeSignature Language="F#" Value="type Methods.SomeType = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public SomeType (int factor0);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 factor0) cil managed" /> + <MemberSignature Language="F#" Value="new Methods.SomeType : int -> Methods.SomeType" Usage="new Methods.SomeType factor0" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="factor0" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="factor0">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeMethod"> + <MemberSignature Language="C#" Value="public int SomeMethod (int a, int b, int c);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 SomeMethod(int32 a, int32 b, int32 c) cil managed" /> + <MemberSignature Language="F#" Value="member this.SomeMethod : int * int * int -> int" Usage="someType.SomeMethod (a, b, c)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + <Parameter Name="c" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeOtherMethod"> + <MemberSignature Language="C#" Value="public int SomeOtherMethod (int a, int b, int c);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 SomeOtherMethod(int32 a, int32 b, int32 c) cil managed" /> + <MemberSignature Language="F#" Value="member this.SomeOtherMethod : int * int * int -> int" Usage="someType.SomeOtherMethod (a, b, c)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + <Parameter Name="c" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeOtherMethod2"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<Tuple<int,int>,Tuple<int,int>>> SomeOtherMethod2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<class System.Tuple`2<int32, int32>, class System.Tuple`2<int32, int32>>> SomeOtherMethod2" /> + <MemberSignature Language="F#" Value="member this.SomeOtherMethod2 : int -> int * int -> int * int" Usage="Methods.SomeType.SomeOtherMethod2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Tuple<System.Int32,System.Int32>,System.Tuple<System.Int32,System.Int32>>></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeOtherMethod3"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<Tuple<Microsoft.FSharp.Core.FSharpFunc<int,int>,int>,Tuple<int,int>> SomeOtherMethod3 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpFunc`2<class System.Tuple`2<class Microsoft.FSharp.Core.FSharpFunc`2<int32, int32>, int32>, class System.Tuple`2<int32, int32>> SomeOtherMethod3" /> + <MemberSignature Language="F#" Value="member this.SomeOtherMethod3 : (int -> int) * int -> int * int" Usage="Methods.SomeType.SomeOtherMethod3" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Tuple<Microsoft.FSharp.Core.FSharpFunc<System.Int32,System.Int32>,System.Int32>,System.Tuple<System.Int32,System.Int32>></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeOtherStaticMethod"> + <MemberSignature Language="C#" Value="public static int SomeOtherStaticMethod (int a, int b, int c);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 SomeOtherStaticMethod(int32 a, int32 b, int32 c) cil managed" /> + <MemberSignature Language="F#" Value="static member SomeOtherStaticMethod : int * int * int -> int" Usage="Methods.SomeType.SomeOtherStaticMethod (a, b, c)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + <Parameter Name="c" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeOtherStaticMethod2"> + <MemberSignature Language="C#" Value="public static int SomeOtherStaticMethod2 (int a, int b, int c);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 SomeOtherStaticMethod2(int32 a, int32 b, int32 c) cil managed" /> + <MemberSignature Language="F#" Value="static member SomeOtherStaticMethod2 : int -> int -> int -> int" Usage="Methods.SomeType.SomeOtherStaticMethod2 a b c" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + <Parameter Name="c" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeOtherStaticMethod3"> + <MemberSignature Language="C#" Value="public static int SomeOtherStaticMethod3 (int a, int b, int c, int d);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 SomeOtherStaticMethod3(int32 a, int32 b, int32 c, int32 d) cil managed" /> + <MemberSignature Language="F#" Value="static member SomeOtherStaticMethod3 : int * int -> int -> int -> int" Usage="Methods.SomeType.SomeOtherStaticMethod3 (a, b) c d" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + <Parameter Name="c" Type="System.Int32" /> + <Parameter Name="d" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <param name="d">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="SomeStaticMethod"> + <MemberSignature Language="C#" Value="public static int SomeStaticMethod (int a, int b, int c);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 SomeStaticMethod(int32 a, int32 b, int32 c) cil managed" /> + <MemberSignature Language="F#" Value="static member SomeStaticMethod : int * int * int -> int" Usage="Methods.SomeType.SomeStaticMethod (a, b, c)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="b" Type="System.Int32" /> + <Parameter Name="c" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <param name="c">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Test"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<Tuple<int,int,int>,int> Test ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.FSharp.Core.FSharpFunc`2<class System.Tuple`3<int32, int32, int32>, int32> Test() cil managed" /> + <MemberSignature Language="F#" Value="member this.Test : unit -> (int * int * int -> int)" Usage="someType.Test " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Tuple<System.Int32,System.Int32,System.Int32>,System.Int32></ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Test2"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<Tuple<int,int,int>,int> Test2 ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.FSharp.Core.FSharpFunc`2<class System.Tuple`3<int32, int32, int32>, int32> Test2() cil managed" /> + <MemberSignature Language="F#" Value="member this.Test2 : unit -> (int * int * int -> int)" Usage="someType.Test2 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Tuple<System.Int32,System.Int32,System.Int32>,System.Int32></ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="TestRefParam"> + <MemberSignature Language="C#" Value="public int TestRefParam (Microsoft.FSharp.Core.FSharpRef<int> i);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 TestRefParam(class Microsoft.FSharp.Core.FSharpRef`1<int32> i) cil managed" /> + <MemberSignature Language="F#" Value="member this.TestRefParam : ref<int> -> int" Usage="someType.TestRefParam i" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="i" Type="Microsoft.FSharp.Core.FSharpRef<System.Int32>" /> + </Parameters> + <Docs> + <param name="i">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Methods.xml b/mdoc/Test/en.expected-fsharp/Methods.xml new file mode 100644 index 00000000..d5a51bb7 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Methods.xml @@ -0,0 +1,46 @@ +<Type Name="Methods" FullName="Methods"> + <TypeSignature Language="C#" Value="public static class Methods" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Methods extends System.Object" /> + <TypeSignature Language="F#" Value="module Methods" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="testIntersection"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.Unit testIntersection { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.Unit testIntersection" /> + <MemberSignature Language="F#" Value="Methods.testIntersection : unit" Usage="Methods.testIntersection" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.Unit</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/NestedModules+X.xml b/mdoc/Test/en.expected-fsharp/NestedModules+X.xml new file mode 100644 index 00000000..c63a7d47 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/NestedModules+X.xml @@ -0,0 +1,46 @@ +<Type Name="NestedModules+X" FullName="NestedModules+X"> + <TypeSignature Language="C#" Value="public static class NestedModules.X" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed NestedModules/X extends System.Object" /> + <TypeSignature Language="F#" Value="module NestedModules.X" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="x"> + <MemberSignature Language="C#" Value="public static int x { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 x" /> + <MemberSignature Language="F#" Value="NestedModules.X.x : int" Usage="NestedModules.X.x" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/NestedModules+Y+Z.xml b/mdoc/Test/en.expected-fsharp/NestedModules+Y+Z.xml new file mode 100644 index 00000000..84407137 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/NestedModules+Y+Z.xml @@ -0,0 +1,49 @@ +<Type Name="NestedModules+Y+Z" FullName="NestedModules+Y+Z"> + <TypeSignature Language="C#" Value="public static class NestedModules.Y.Z" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed NestedModules/Y/Z extends System.Object" /> + <TypeSignature Language="F#" Value="module NestedModules.Y.Z" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.AutoOpen</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="z"> + <MemberSignature Language="C#" Value="public static int z { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 z" /> + <MemberSignature Language="F#" Value="NestedModules.Y.Z.z : int" Usage="NestedModules.Y.Z.z" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/NestedModules+Y.xml b/mdoc/Test/en.expected-fsharp/NestedModules+Y.xml new file mode 100644 index 00000000..d3320fb3 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/NestedModules+Y.xml @@ -0,0 +1,46 @@ +<Type Name="NestedModules+Y" FullName="NestedModules+Y"> + <TypeSignature Language="C#" Value="public static class NestedModules.Y" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed NestedModules/Y extends System.Object" /> + <TypeSignature Language="F#" Value="module NestedModules.Y" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="y"> + <MemberSignature Language="C#" Value="public static int y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 y" /> + <MemberSignature Language="F#" Value="NestedModules.Y.y : int" Usage="NestedModules.Y.y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/NestedModules.xml b/mdoc/Test/en.expected-fsharp/NestedModules.xml new file mode 100644 index 00000000..7462a08e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/NestedModules.xml @@ -0,0 +1,23 @@ +<Type Name="NestedModules" FullName="NestedModules"> + <TypeSignature Language="C#" Value="public static class NestedModules" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed NestedModules extends System.Object" /> + <TypeSignature Language="F#" Value="module NestedModules" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/NestedTypes.xml b/mdoc/Test/en.expected-fsharp/NestedTypes.xml new file mode 100644 index 00000000..203cfa27 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/NestedTypes.xml @@ -0,0 +1,23 @@ +<Type Name="NestedTypes" FullName="NestedTypes"> + <TypeSignature Language="C#" Value="public static class NestedTypes" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed NestedTypes extends System.Object" /> + <TypeSignature Language="F#" Value="module NestedTypes" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/OperatorGlobalLevel.xml b/mdoc/Test/en.expected-fsharp/OperatorGlobalLevel.xml new file mode 100644 index 00000000..18146ef1 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/OperatorGlobalLevel.xml @@ -0,0 +1,74 @@ +<Type Name="OperatorGlobalLevel" FullName="OperatorGlobalLevel"> + <TypeSignature Language="C#" Value="public static class OperatorGlobalLevel" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed OperatorGlobalLevel extends System.Object" /> + <TypeSignature Language="F#" Value="module OperatorGlobalLevel" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="i"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<int,int>> i { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<int32, int32>> i" /> + <MemberSignature Language="F#" Value="OperatorGlobalLevel.i : int -> int -> int" Usage="OperatorGlobalLevel.i" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Int32,System.Int32>></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_PlusQmark"> + <MemberSignature Language="C#" Value="public static int op_PlusQmark (int x, int y);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname int32 op_PlusQmark(int32 x, int32 y) cil managed" /> + <MemberSignature Language="F#" Value="( +? ) : int -> int -> int" Usage="x +? y" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + <Parameter Name="y" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/OperatorsOverloading+Vector.xml b/mdoc/Test/en.expected-fsharp/OperatorsOverloading+Vector.xml new file mode 100644 index 00000000..f75c8db8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/OperatorsOverloading+Vector.xml @@ -0,0 +1,320 @@ +<Type Name="OperatorsOverloading+Vector" FullName="OperatorsOverloading+Vector"> + <TypeSignature Language="C#" Value="public class OperatorsOverloading.Vector" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable OperatorsOverloading/Vector extends System.Object" /> + <TypeSignature Language="F#" Value="type OperatorsOverloading.Vector = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Vector (double x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new OperatorsOverloading.Vector : double * double -> OperatorsOverloading.Vector" Usage="new OperatorsOverloading.Vector (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_Addition"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector operator + (OperatorsOverloading.Vector v, OperatorsOverloading.Vector v2);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_Addition(OperatorsOverloading/Vector v, OperatorsOverloading/Vector v2) cil managed" /> + <MemberSignature Language="F#" Value="static member ( + ) : OperatorsOverloading.Vector * OperatorsOverloading.Vector -> OperatorsOverloading.Vector" Usage="v + v2" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="v" Type="OperatorsOverloading+Vector" /> + <Parameter Name="v2" Type="OperatorsOverloading+Vector" /> + </Parameters> + <Docs> + <param name="v">To be added.</param> + <param name="v2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_BarPlusMinusPlus"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector op_BarPlusMinusPlus (int a, OperatorsOverloading.Vector v);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_BarPlusMinusPlus(int32 a, OperatorsOverloading/Vector v) cil managed" /> + <MemberSignature Language="F#" Value="static member ( |+-+ ) : int * OperatorsOverloading.Vector -> OperatorsOverloading.Vector" Usage="a |+-+ v" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Int32" /> + <Parameter Name="v" Type="OperatorsOverloading+Vector" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="v">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_DynamicAssignment<f>"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector op_DynamicAssignment<f> (double a, f v, OperatorsOverloading.Vector b);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_DynamicAssignment<f>(float64 a, !!f v, OperatorsOverloading/Vector b) cil managed" /> + <MemberSignature Language="F#" Value="static member ( ?<- ) : double * 'f * OperatorsOverloading.Vector -> OperatorsOverloading.Vector" Usage="a ?<- v b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="f" /> + </TypeParameters> + <Parameters> + <Parameter Name="a" Type="System.Double" /> + <Parameter Name="v" Type="f" /> + <Parameter Name="b" Type="OperatorsOverloading+Vector" /> + </Parameters> + <Docs> + <typeparam name="f">To be added.</typeparam> + <param name="a">To be added.</param> + <param name="v">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_ExclusiveOr"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector operator ^ (double a, OperatorsOverloading.Vector v);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_ExclusiveOr(float64 a, OperatorsOverloading/Vector v) cil managed" /> + <MemberSignature Language="F#" Value="static member ( ^^^ ) : double * OperatorsOverloading.Vector -> OperatorsOverloading.Vector" Usage="a ^^^ v" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="System.Double" /> + <Parameter Name="v" Type="OperatorsOverloading+Vector" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="v">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_LogicalNot"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector operator ! (OperatorsOverloading.Vector v);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_LogicalNot(OperatorsOverloading/Vector v) cil managed" /> + <MemberSignature Language="F#" Value="static member ( ~~~ ) : OperatorsOverloading.Vector -> OperatorsOverloading.Vector" Usage="~~~ v" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="v" Type="OperatorsOverloading+Vector" /> + </Parameters> + <Docs> + <param name="v">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_Multiply"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector operator * (OperatorsOverloading.Vector v, double a);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_Multiply(OperatorsOverloading/Vector v, float64 a) cil managed" /> + <MemberSignature Language="F#" Value="static member ( * ) : OperatorsOverloading.Vector * double -> OperatorsOverloading.Vector" Usage="v * a" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="v" Type="OperatorsOverloading+Vector" /> + <Parameter Name="a" Type="System.Double" /> + </Parameters> + <Docs> + <param name="v">To be added.</param> + <param name="a">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_Range<a,b>"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector op_Range<a,b> (a start, b finish);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_Range<a, b>(!!a start, !!b finish) cil managed" /> + <MemberSignature Language="F#" Value="static member ( .. ) : 'a * 'b -> OperatorsOverloading.Vector" Usage="start .. finish" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + <TypeParameter Name="b" /> + </TypeParameters> + <Parameters> + <Parameter Name="start" Type="a" /> + <Parameter Name="finish" Type="b" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <typeparam name="b">To be added.</typeparam> + <param name="start">To be added.</param> + <param name="finish">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_RangeStep<c,d,e>"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector op_RangeStep<c,d,e> (c start, d step, e finish);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_RangeStep<c, d, e>(!!c start, !!d step, !!e finish) cil managed" /> + <MemberSignature Language="F#" Value="static member ( .. .. ) : 'c * 'd * 'e -> OperatorsOverloading.Vector" Usage="start .. step .. finish" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="c" /> + <TypeParameter Name="d" /> + <TypeParameter Name="e" /> + </TypeParameters> + <Parameters> + <Parameter Name="start" Type="c" /> + <Parameter Name="step" Type="d" /> + <Parameter Name="finish" Type="e" /> + </Parameters> + <Docs> + <typeparam name="c">To be added.</typeparam> + <typeparam name="d">To be added.</typeparam> + <typeparam name="e">To be added.</typeparam> + <param name="start">To be added.</param> + <param name="step">To be added.</param> + <param name="finish">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_UnaryNegation"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector operator - (OperatorsOverloading.Vector v);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname OperatorsOverloading/Vector op_UnaryNegation(OperatorsOverloading/Vector v) cil managed" /> + <MemberSignature Language="F#" Value="static member ( ~- ) : OperatorsOverloading.Vector -> OperatorsOverloading.Vector" Usage="- v" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="v" Type="OperatorsOverloading+Vector" /> + </Parameters> + <Docs> + <param name="v">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance string ToString() cil managed" /> + <MemberSignature Language="F#" Value="override this.ToString : unit -> string" Usage="vector.ToString " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x"> + <MemberSignature Language="C#" Value="public double x { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 x" /> + <MemberSignature Language="F#" Value="member this.x : double" Usage="OperatorsOverloading.Vector.x" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="y"> + <MemberSignature Language="C#" Value="public double y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 y" /> + <MemberSignature Language="F#" Value="member this.y : double" Usage="OperatorsOverloading.Vector.y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/OperatorsOverloading.xml b/mdoc/Test/en.expected-fsharp/OperatorsOverloading.xml new file mode 100644 index 00000000..e787fc90 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/OperatorsOverloading.xml @@ -0,0 +1,186 @@ +<Type Name="OperatorsOverloading" FullName="OperatorsOverloading"> + <TypeSignature Language="C#" Value="public static class OperatorsOverloading" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed OperatorsOverloading extends System.Object" /> + <TypeSignature Language="F#" Value="module OperatorsOverloading" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="v1"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector v1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property OperatorsOverloading/Vector v1" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v1 : OperatorsOverloading.Vector" Usage="OperatorsOverloading.v1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v10<T2,T3,T1>"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T2,T3>,Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T1,T2>,Microsoft.FSharp.Core.FSharpFunc<T1,T3>>> v10<T2,T3,T1> ();" /> + <MemberSignature Language="ILAsm" Value=".method public static class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.FSharpFunc`2<!!T2, !!T3>, class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.FSharpFunc`2<!!T1, !!T2>, class Microsoft.FSharp.Core.FSharpFunc`2<!!T1, !!T3>>> v10<T2, T3, T1>() cil managed" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v10 : unit -> ('T2 -> 'T3 -> 'T1 -> 'T2 -> 'T1 -> 'T3)" Usage="OperatorsOverloading.v10 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T2,T3>,Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T1,T2>,Microsoft.FSharp.Core.FSharpFunc<T1,T3>>></ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T2" /> + <TypeParameter Name="T3" /> + <TypeParameter Name="T1" /> + </TypeParameters> + <Parameters /> + <Docs> + <typeparam name="T2">To be added.</typeparam> + <typeparam name="T3">To be added.</typeparam> + <typeparam name="T1">To be added.</typeparam> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v2"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector v2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property OperatorsOverloading/Vector v2" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v2 : OperatorsOverloading.Vector" Usage="OperatorsOverloading.v2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v4"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector v4 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property OperatorsOverloading/Vector v4" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v4 : OperatorsOverloading.Vector" Usage="OperatorsOverloading.v4" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v5"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector v5 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property OperatorsOverloading/Vector v5" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v5 : OperatorsOverloading.Vector" Usage="OperatorsOverloading.v5" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v7"> + <MemberSignature Language="C#" Value="public static OperatorsOverloading.Vector v7 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property OperatorsOverloading/Vector v7" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v7 : OperatorsOverloading.Vector" Usage="OperatorsOverloading.v7" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>OperatorsOverloading+Vector</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v9<T2,T3,T1>"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T2,T3>,Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T1,T2>,Microsoft.FSharp.Core.FSharpFunc<T1,T3>>> v9<T2,T3,T1> ();" /> + <MemberSignature Language="ILAsm" Value=".method public static class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.FSharpFunc`2<!!T2, !!T3>, class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Core.FSharpFunc`2<!!T1, !!T2>, class Microsoft.FSharp.Core.FSharpFunc`2<!!T1, !!T3>>> v9<T2, T3, T1>() cil managed" /> + <MemberSignature Language="F#" Value="OperatorsOverloading.v9 : unit -> ('T2 -> 'T3 -> 'T1 -> 'T2 -> 'T1 -> 'T3)" Usage="OperatorsOverloading.v9 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T2,T3>,Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Core.FSharpFunc<T1,T2>,Microsoft.FSharp.Core.FSharpFunc<T1,T3>>></ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T2" /> + <TypeParameter Name="T3" /> + <TypeParameter Name="T1" /> + </TypeParameters> + <Parameters /> + <Docs> + <typeparam name="T2">To be added.</typeparam> + <typeparam name="T3">To be added.</typeparam> + <typeparam name="T1">To be added.</typeparam> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Color.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Color.xml new file mode 100644 index 00000000..e5570fa2 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Color.xml @@ -0,0 +1,71 @@ +<Type Name="PatternMatchingExamples+Color" FullName="PatternMatching.PatternMatchingExamples+Color"> + <TypeSignature Language="C#" Value="public enum PatternMatchingExamples.Color" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed PatternMatchingExamples/Color extends System.Enum" /> + <TypeSignature Language="F#" Value="type PatternMatchingExamples.Color = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Enum</BaseTypeName> + </Base> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Blue"> + <MemberSignature Language="C#" Value="Blue" /> + <MemberSignature Language="ILAsm" Value=".field public static literal valuetype PatternMatching.PatternMatchingExamples/Color Blue = int32(2)" /> + <MemberSignature Language="F#" Value="Blue = 2" Usage="PatternMatching.PatternMatchingExamples.Color.Blue" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+Color</ReturnType> + </ReturnValue> + <MemberValue>2</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + <Member MemberName="Green"> + <MemberSignature Language="C#" Value="Green" /> + <MemberSignature Language="ILAsm" Value=".field public static literal valuetype PatternMatching.PatternMatchingExamples/Color Green = int32(1)" /> + <MemberSignature Language="F#" Value="Green = 1" Usage="PatternMatching.PatternMatchingExamples.Color.Green" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+Color</ReturnType> + </ReturnValue> + <MemberValue>1</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + <Member MemberName="Red"> + <MemberSignature Language="C#" Value="Red" /> + <MemberSignature Language="ILAsm" Value=".field public static literal valuetype PatternMatching.PatternMatchingExamples/Color Red = int32(0)" /> + <MemberSignature Language="F#" Value="Red = 0" Usage="PatternMatching.PatternMatchingExamples.Color.Red" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+Color</ReturnType> + </ReturnValue> + <MemberValue>0</MemberValue> + <Docs> + <summary>To be added.</summary> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+MyRecord.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+MyRecord.xml new file mode 100644 index 00000000..a74eb333 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+MyRecord.xml @@ -0,0 +1,281 @@ +<Type Name="PatternMatchingExamples+MyRecord" FullName="PatternMatching.PatternMatchingExamples+MyRecord"> + <TypeSignature Language="C#" Value="public sealed class PatternMatchingExamples.MyRecord : IComparable, IComparable<PatternMatching.PatternMatchingExamples.MyRecord>, IEquatable<PatternMatching.PatternMatchingExamples.MyRecord>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed PatternMatchingExamples/MyRecord extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<class PatternMatching.PatternMatchingExamples/MyRecord>, class System.IEquatable`1<class PatternMatching.PatternMatchingExamples/MyRecord>" /> + <TypeSignature Language="F#" Value="type PatternMatchingExamples.MyRecord = {}" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<PatternMatching.PatternMatchingExamples+MyRecord></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<PatternMatching.PatternMatchingExamples+MyRecord></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.RecordType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyRecord (string name, int iD);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string name, int32 iD) cil managed" /> + <MemberSignature Language="F#" Value="new PatternMatching.PatternMatchingExamples.MyRecord : string * int -> PatternMatching.PatternMatchingExamples.MyRecord" Usage="new PatternMatching.PatternMatchingExamples.MyRecord (name, iD)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="name" Type="System.String" /> + <Parameter Name="iD" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="name">To be added.</param> + <param name="iD">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (PatternMatching.PatternMatchingExamples.MyRecord obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(class PatternMatching.PatternMatchingExamples/MyRecord obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="PatternMatching.PatternMatchingExamples+MyRecord" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (PatternMatching.PatternMatchingExamples.MyRecord obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(class PatternMatching.PatternMatchingExamples/MyRecord obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="PatternMatching.PatternMatchingExamples+MyRecord" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ID"> + <MemberSignature Language="C#" Value="public int ID { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 ID" /> + <MemberSignature Language="F#" Value="ID : int" Usage="PatternMatching.PatternMatchingExamples.MyRecord.ID" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Name"> + <MemberSignature Language="C#" Value="public string Name { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Name" /> + <MemberSignature Language="F#" Value="Name : string" Usage="PatternMatching.PatternMatchingExamples.MyRecord.Name" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+FirstLast.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+FirstLast.xml new file mode 100644 index 00000000..bad5d390 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+FirstLast.xml @@ -0,0 +1,83 @@ +<Type Name="PatternMatchingExamples+PersonName+FirstLast" FullName="PatternMatching.PatternMatchingExamples+PersonName+FirstLast"> + <TypeSignature Language="C#" Value="public class PatternMatchingExamples.PersonName.FirstLast : PatternMatching.PatternMatchingExamples.PersonName" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit PatternMatchingExamples/PersonName/FirstLast extends PatternMatching.PatternMatchingExamples/PersonName" /> + <TypeSignature Language="F#" Value="PatternMatchingExamples.PersonName.FirstLast : string * string -> PatternMatchingExamples.PersonName" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>PatternMatching.PatternMatchingExamples+PersonName</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(PatternMatching.PatternMatchingExamples/PersonName/FirstLast@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Item1"> + <MemberSignature Language="C#" Value="public string Item1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Item1" /> + <MemberSignature Language="F#" Value="val Item1 : string" Usage="PatternMatching.PatternMatchingExamples.PersonName.FirstLast.Item1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Item2"> + <MemberSignature Language="C#" Value="public string Item2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Item2" /> + <MemberSignature Language="F#" Value="val Item2 : string" Usage="PatternMatching.PatternMatchingExamples.PersonName.FirstLast.Item2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2, 1)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+FirstOnly.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+FirstOnly.xml new file mode 100644 index 00000000..d184829e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+FirstOnly.xml @@ -0,0 +1,55 @@ +<Type Name="PatternMatchingExamples+PersonName+FirstOnly" FullName="PatternMatching.PatternMatchingExamples+PersonName+FirstOnly"> + <TypeSignature Language="C#" Value="public class PatternMatchingExamples.PersonName.FirstOnly : PatternMatching.PatternMatchingExamples.PersonName" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit PatternMatchingExamples/PersonName/FirstOnly extends PatternMatching.PatternMatchingExamples/PersonName" /> + <TypeSignature Language="F#" Value="PatternMatchingExamples.PersonName.FirstOnly : string -> PatternMatchingExamples.PersonName" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>PatternMatching.PatternMatchingExamples+PersonName</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(PatternMatching.PatternMatchingExamples/PersonName/FirstOnly@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Item"> + <MemberSignature Language="C#" Value="public string Item { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Item" /> + <MemberSignature Language="F#" Value="val Item : string" Usage="PatternMatching.PatternMatchingExamples.PersonName.FirstOnly.Item" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+LastOnly.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+LastOnly.xml new file mode 100644 index 00000000..e818e0fd --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+LastOnly.xml @@ -0,0 +1,55 @@ +<Type Name="PatternMatchingExamples+PersonName+LastOnly" FullName="PatternMatching.PatternMatchingExamples+PersonName+LastOnly"> + <TypeSignature Language="C#" Value="public class PatternMatchingExamples.PersonName.LastOnly : PatternMatching.PatternMatchingExamples.PersonName" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit PatternMatchingExamples/PersonName/LastOnly extends PatternMatching.PatternMatchingExamples/PersonName" /> + <TypeSignature Language="F#" Value="PatternMatchingExamples.PersonName.LastOnly : string -> PatternMatchingExamples.PersonName" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>PatternMatching.PatternMatchingExamples+PersonName</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(PatternMatching.PatternMatchingExamples/PersonName/LastOnly@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Item"> + <MemberSignature Language="C#" Value="public string Item { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Item" /> + <MemberSignature Language="F#" Value="val Item : string" Usage="PatternMatching.PatternMatchingExamples.PersonName.LastOnly.Item" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+Tags.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+Tags.xml new file mode 100644 index 00000000..d36792b8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName+Tags.xml @@ -0,0 +1,69 @@ +<Type Name="PatternMatchingExamples+PersonName+Tags" FullName="PatternMatching.PatternMatchingExamples+PersonName+Tags"> + <TypeSignature Language="C#" Value="public static class PatternMatchingExamples.PersonName.Tags" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed PatternMatchingExamples/PersonName/Tags extends System.Object" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="FirstLast"> + <MemberSignature Language="C#" Value="public const int FirstLast = 2;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 FirstLast = (2)" /> + <MemberSignature Language="F#" Value="val mutable FirstLast : int" Usage="PatternMatching.PatternMatchingExamples.PersonName.Tags.FirstLast" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>2</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="FirstOnly"> + <MemberSignature Language="C#" Value="public const int FirstOnly = 0;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 FirstOnly = (0)" /> + <MemberSignature Language="F#" Value="val mutable FirstOnly : int" Usage="PatternMatching.PatternMatchingExamples.PersonName.Tags.FirstOnly" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>0</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="LastOnly"> + <MemberSignature Language="C#" Value="public const int LastOnly = 1;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 LastOnly = (1)" /> + <MemberSignature Language="F#" Value="val mutable LastOnly : int" Usage="PatternMatching.PatternMatchingExamples.PersonName.Tags.LastOnly" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>1</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName.xml new file mode 100644 index 00000000..bd88f424 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+PersonName.xml @@ -0,0 +1,406 @@ +<Type Name="PatternMatchingExamples+PersonName" FullName="PatternMatching.PatternMatchingExamples+PersonName"> + <TypeSignature Language="C#" Value="public abstract class PatternMatchingExamples.PersonName : IComparable, IComparable<PatternMatching.PatternMatchingExamples.PersonName>, IEquatable<PatternMatching.PatternMatchingExamples.PersonName>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto abstract serializable beforefieldinit PatternMatchingExamples/PersonName extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<class PatternMatching.PatternMatchingExamples/PersonName>, class System.IEquatable`1<class PatternMatching.PatternMatchingExamples/PersonName>" /> + <TypeSignature Language="F#" Value="type PatternMatchingExamples.PersonName = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<PatternMatching.PatternMatchingExamples+PersonName></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<PatternMatching.PatternMatchingExamples+PersonName></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.SumType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (PatternMatching.PatternMatchingExamples.PersonName obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(class PatternMatching.PatternMatchingExamples/PersonName obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="PatternMatching.PatternMatchingExamples+PersonName" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (PatternMatching.PatternMatchingExamples.PersonName obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(class PatternMatching.PatternMatchingExamples/PersonName obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="PatternMatching.PatternMatchingExamples+PersonName" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsFirstLast"> + <MemberSignature Language="C#" Value="public bool IsFirstLast { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsFirstLast" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsFirstOnly"> + <MemberSignature Language="C#" Value="public bool IsFirstOnly { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsFirstOnly" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsLastOnly"> + <MemberSignature Language="C#" Value="public bool IsLastOnly { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsLastOnly" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewFirstLast"> + <MemberSignature Language="C#" Value="public static PatternMatching.PatternMatchingExamples.PersonName NewFirstLast (string item1, string item2);" /> + <MemberSignature Language="ILAsm" Value=".method public static class PatternMatching.PatternMatchingExamples/PersonName NewFirstLast(string item1, string item2) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+PersonName</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="item1" Type="System.String" /> + <Parameter Name="item2" Type="System.String" /> + </Parameters> + <Docs> + <param name="item1">To be added.</param> + <param name="item2">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewFirstOnly"> + <MemberSignature Language="C#" Value="public static PatternMatching.PatternMatchingExamples.PersonName NewFirstOnly (string item);" /> + <MemberSignature Language="ILAsm" Value=".method public static class PatternMatching.PatternMatchingExamples/PersonName NewFirstOnly(string item) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+PersonName</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="item" Type="System.String" /> + </Parameters> + <Docs> + <param name="item">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewLastOnly"> + <MemberSignature Language="C#" Value="public static PatternMatching.PatternMatchingExamples.PersonName NewLastOnly (string item);" /> + <MemberSignature Language="ILAsm" Value=".method public static class PatternMatching.PatternMatchingExamples/PersonName NewLastOnly(string item) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+PersonName</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="item" Type="System.String" /> + </Parameters> + <Docs> + <param name="item">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Tag"> + <MemberSignature Language="C#" Value="public int Tag { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Tag" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Circle.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Circle.xml new file mode 100644 index 00000000..495a1914 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Circle.xml @@ -0,0 +1,55 @@ +<Type Name="PatternMatchingExamples+Shape+Circle" FullName="PatternMatching.PatternMatchingExamples+Shape+Circle"> + <TypeSignature Language="C#" Value="public class PatternMatchingExamples.Shape.Circle : PatternMatching.PatternMatchingExamples.Shape" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit PatternMatchingExamples/Shape/Circle extends PatternMatching.PatternMatchingExamples/Shape" /> + <TypeSignature Language="F#" Value="PatternMatchingExamples.Shape.Circle : double -> PatternMatchingExamples.Shape" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>PatternMatching.PatternMatchingExamples+Shape</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(PatternMatching.PatternMatchingExamples/Shape/Circle@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="radius"> + <MemberSignature Language="C#" Value="public double radius { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 radius" /> + <MemberSignature Language="F#" Value="val radius : double" Usage="PatternMatching.PatternMatchingExamples.Shape.Circle.radius" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Rectangle.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Rectangle.xml new file mode 100644 index 00000000..fbfb4bc4 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Rectangle.xml @@ -0,0 +1,83 @@ +<Type Name="PatternMatchingExamples+Shape+Rectangle" FullName="PatternMatching.PatternMatchingExamples+Shape+Rectangle"> + <TypeSignature Language="C#" Value="public class PatternMatchingExamples.Shape.Rectangle : PatternMatching.PatternMatchingExamples.Shape" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable beforefieldinit PatternMatchingExamples/Shape/Rectangle extends PatternMatching.PatternMatchingExamples/Shape" /> + <TypeSignature Language="F#" Value="PatternMatchingExamples.Shape.Rectangle : double * double -> PatternMatchingExamples.Shape" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>PatternMatching.PatternMatchingExamples+Shape</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerTypeProxy(typeof(PatternMatching.PatternMatchingExamples/Shape/Rectangle@DebugTypeProxy))</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="height"> + <MemberSignature Language="C#" Value="public double height { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 height" /> + <MemberSignature Language="F#" Value="val height : double" Usage="PatternMatching.PatternMatchingExamples.Shape.Rectangle.height" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="width"> + <MemberSignature Language="C#" Value="public double width { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 width" /> + <MemberSignature Language="F#" Value="val width : double" Usage="PatternMatching.PatternMatchingExamples.Shape.Rectangle.width" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0, 1)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Tags.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Tags.xml new file mode 100644 index 00000000..9e3041a4 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape+Tags.xml @@ -0,0 +1,52 @@ +<Type Name="PatternMatchingExamples+Shape+Tags" FullName="PatternMatching.PatternMatchingExamples+Shape+Tags"> + <TypeSignature Language="C#" Value="public static class PatternMatchingExamples.Shape.Tags" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed PatternMatchingExamples/Shape/Tags extends System.Object" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Circle"> + <MemberSignature Language="C#" Value="public const int Circle = 1;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Circle = (1)" /> + <MemberSignature Language="F#" Value="val mutable Circle : int" Usage="PatternMatching.PatternMatchingExamples.Shape.Tags.Circle" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>1</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Rectangle"> + <MemberSignature Language="C#" Value="public const int Rectangle = 0;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Rectangle = (0)" /> + <MemberSignature Language="F#" Value="val mutable Rectangle : int" Usage="PatternMatching.PatternMatchingExamples.Shape.Tags.Rectangle" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>0</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape.xml new file mode 100644 index 00000000..107b7480 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples+Shape.xml @@ -0,0 +1,354 @@ +<Type Name="PatternMatchingExamples+Shape" FullName="PatternMatching.PatternMatchingExamples+Shape"> + <TypeSignature Language="C#" Value="public abstract class PatternMatchingExamples.Shape : IComparable, IComparable<PatternMatching.PatternMatchingExamples.Shape>, IEquatable<PatternMatching.PatternMatchingExamples.Shape>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto abstract serializable beforefieldinit PatternMatchingExamples/Shape extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<class PatternMatching.PatternMatchingExamples/Shape>, class System.IEquatable`1<class PatternMatching.PatternMatchingExamples/Shape>" /> + <TypeSignature Language="F#" Value="type PatternMatchingExamples.Shape = " /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<PatternMatching.PatternMatchingExamples+Shape></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<PatternMatching.PatternMatchingExamples+Shape></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.SumType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerDisplay("{__DebugDisplay(),nq}")</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (PatternMatching.PatternMatchingExamples.Shape obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(class PatternMatching.PatternMatchingExamples/Shape obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="PatternMatching.PatternMatchingExamples+Shape" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (PatternMatching.PatternMatchingExamples.Shape obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(class PatternMatching.PatternMatchingExamples/Shape obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="PatternMatching.PatternMatchingExamples+Shape" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsCircle"> + <MemberSignature Language="C#" Value="public bool IsCircle { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsCircle" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsRectangle"> + <MemberSignature Language="C#" Value="public bool IsRectangle { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance bool IsRectangle" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewCircle"> + <MemberSignature Language="C#" Value="public static PatternMatching.PatternMatchingExamples.Shape NewCircle (double _radius);" /> + <MemberSignature Language="ILAsm" Value=".method public static class PatternMatching.PatternMatchingExamples/Shape NewCircle(float64 _radius) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+Shape</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_radius" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_radius">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="NewRectangle"> + <MemberSignature Language="C#" Value="public static PatternMatching.PatternMatchingExamples.Shape NewRectangle (double _height, double _width);" /> + <MemberSignature Language="ILAsm" Value=".method public static class PatternMatching.PatternMatchingExamples/Shape NewRectangle(float64 _height, float64 _width) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.UnionCase, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+Shape</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="_height" Type="System.Double" /> + <Parameter Name="_width" Type="System.Double" /> + </Parameters> + <Docs> + <param name="_height">To be added.</param> + <param name="_width">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Tag"> + <MemberSignature Language="C#" Value="public int Tag { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Tag" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples.xml b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples.xml new file mode 100644 index 00000000..3d60459b --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/PatternMatching/PatternMatchingExamples.xml @@ -0,0 +1,666 @@ +<Type Name="PatternMatchingExamples" FullName="PatternMatching.PatternMatchingExamples"> + <TypeSignature Language="C#" Value="public static class PatternMatchingExamples" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed PatternMatchingExamples extends System.Object" /> + <TypeSignature Language="F#" Value="module PatternMatchingExamples" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="constructQuery"> + <MemberSignature Language="C#" Value="public static void constructQuery (PatternMatching.PatternMatchingExamples.PersonName personName);" /> + <MemberSignature Language="ILAsm" Value=".method public static void constructQuery(class PatternMatching.PatternMatchingExamples/PersonName personName) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.constructQuery : PatternMatching.PatternMatchingExamples.PersonName -> unit" Usage="PatternMatching.PatternMatchingExamples.constructQuery personName" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="personName" Type="PatternMatching.PatternMatchingExamples+PersonName" /> + </Parameters> + <Docs> + <param name="personName">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="countValues<a>"> + <MemberSignature Language="C#" Value="public static int countValues<a> (Microsoft.FSharp.Collections.FSharpList<a> list, a value);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 countValues<a>(class Microsoft.FSharp.Collections.FSharpList`1<!!a> list, !!a value) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.countValues : List<'a> -> 'a -> int" Usage="PatternMatching.PatternMatchingExamples.countValues list value" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="list" Type="Microsoft.FSharp.Collections.FSharpList<a>" /> + <Parameter Name="value" Type="a" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="list">To be added.</param> + <param name="value">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="countValues2<a>"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Collections.FSharpList<a>,Microsoft.FSharp.Core.FSharpFunc<a,int>> countValues2<a> ();" /> + <MemberSignature Language="ILAsm" Value=".method public static class Microsoft.FSharp.Core.FSharpFunc`2<class Microsoft.FSharp.Collections.FSharpList`1<!!a>, class Microsoft.FSharp.Core.FSharpFunc`2<!!a, int32>> countValues2<a>() cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.countValues2 : unit -> (List<'a> -> 'a -> int)" Usage="PatternMatching.PatternMatchingExamples.countValues2 " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<Microsoft.FSharp.Collections.FSharpList<a>,Microsoft.FSharp.Core.FSharpFunc<a,System.Int32>></ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters /> + <Docs> + <typeparam name="a">To be added.</typeparam> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="detect1"> + <MemberSignature Language="C#" Value="public static void detect1 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public static void detect1(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.detect1 : int -> unit" Usage="PatternMatching.PatternMatchingExamples.detect1 x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="detectZeroAND"> + <MemberSignature Language="C#" Value="public static void detectZeroAND (int point_0, int point_1);" /> + <MemberSignature Language="ILAsm" Value=".method public static void detectZeroAND(int32 point_0, int32 point_1) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.detectZeroAND : int * int -> unit" Usage="PatternMatching.PatternMatchingExamples.detectZeroAND (point_0, point_1)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="point_0" Type="System.Int32" /> + <Parameter Name="point_1" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="point_0">To be added.</param> + <param name="point_1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="detectZeroOR"> + <MemberSignature Language="C#" Value="public static void detectZeroOR (int point_0, int point_1);" /> + <MemberSignature Language="ILAsm" Value=".method public static void detectZeroOR(int32 point_0, int32 point_1) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.detectZeroOR : int * int -> unit" Usage="PatternMatching.PatternMatchingExamples.detectZeroOR (point_0, point_1)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="point_0" Type="System.Int32" /> + <Parameter Name="point_1" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="point_0">To be added.</param> + <param name="point_1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="detectZeroTuple"> + <MemberSignature Language="C#" Value="public static void detectZeroTuple (int point_0, int point_1);" /> + <MemberSignature Language="ILAsm" Value=".method public static void detectZeroTuple(int32 point_0, int32 point_1) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.detectZeroTuple : int * int -> unit" Usage="PatternMatching.PatternMatchingExamples.detectZeroTuple (point_0, point_1)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="point_0" Type="System.Int32" /> + <Parameter Name="point_1" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="point_0">To be added.</param> + <param name="point_1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="filter123"> + <MemberSignature Language="C#" Value="public static void filter123 (int x);" /> + <MemberSignature Language="ILAsm" Value=".method public static void filter123(int32 x) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.filter123 : int -> unit" Usage="PatternMatching.PatternMatchingExamples.filter123 x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="fs"> + <MemberSignature Language="C#" Value="public static System.IO.FileStream fs { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class System.IO.FileStream fs" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.fs : System.IO.FileStream" Usage="PatternMatching.PatternMatchingExamples.fs" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.IO.FileStream</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public static void function1 (int x_0, int x_1);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function1(int32 x_0, int32 x_1) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.function1 : int * int -> unit" Usage="PatternMatching.PatternMatchingExamples.function1 (x_0, x_1)" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x_0" Type="System.Int32" /> + <Parameter Name="x_1" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x_0">To be added.</param> + <param name="x_1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="IsMatchByName"> + <MemberSignature Language="C#" Value="public static bool IsMatchByName (PatternMatching.PatternMatchingExamples.MyRecord record1, string name);" /> + <MemberSignature Language="ILAsm" Value=".method public static bool IsMatchByName(class PatternMatching.PatternMatchingExamples/MyRecord record1, string name) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.IsMatchByName : PatternMatching.PatternMatchingExamples.MyRecord -> string -> bool" Usage="PatternMatching.PatternMatchingExamples.IsMatchByName record1 name" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="record1" Type="PatternMatching.PatternMatchingExamples+MyRecord" /> + <Parameter Name="name" Type="System.String" /> + </Parameters> + <Docs> + <param name="record1">To be added.</param> + <param name="name">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="isMatched1"> + <MemberSignature Language="C#" Value="public static bool isMatched1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property bool isMatched1" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.isMatched1 : bool" Usage="PatternMatching.PatternMatchingExamples.isMatched1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="isMatched2"> + <MemberSignature Language="C#" Value="public static bool isMatched2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property bool isMatched2" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.isMatched2 : bool" Usage="PatternMatching.PatternMatchingExamples.isMatched2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="list1"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Collections.FSharpList<int> list1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Collections.FSharpList`1<int32> list1" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.list1 : List<int>" Usage="PatternMatching.PatternMatchingExamples.list1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Collections.FSharpList<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="listLength<a>"> + <MemberSignature Language="C#" Value="public static int listLength<a> (Microsoft.FSharp.Collections.FSharpList<a> list);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 listLength<a>(class Microsoft.FSharp.Collections.FSharpList`1<!!a> list) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.listLength : List<'a> -> int" Usage="PatternMatching.PatternMatchingExamples.listLength list" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="a" /> + </TypeParameters> + <Parameters> + <Parameter Name="list" Type="Microsoft.FSharp.Collections.FSharpList<a>" /> + </Parameters> + <Docs> + <typeparam name="a">To be added.</typeparam> + <param name="list">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="matchShape"> + <MemberSignature Language="C#" Value="public static void matchShape (PatternMatching.PatternMatchingExamples.Shape shape);" /> + <MemberSignature Language="ILAsm" Value=".method public static void matchShape(class PatternMatching.PatternMatchingExamples/Shape shape) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.matchShape : PatternMatching.PatternMatchingExamples.Shape -> unit" Usage="PatternMatching.PatternMatchingExamples.matchShape shape" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="shape" Type="PatternMatching.PatternMatchingExamples+Shape" /> + </Parameters> + <Docs> + <param name="shape">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="matchShape2"> + <MemberSignature Language="C#" Value="public static void matchShape2 (PatternMatching.PatternMatchingExamples.Shape shape);" /> + <MemberSignature Language="ILAsm" Value=".method public static void matchShape2(class PatternMatching.PatternMatchingExamples/Shape shape) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.matchShape2 : PatternMatching.PatternMatchingExamples.Shape -> unit" Usage="PatternMatching.PatternMatchingExamples.matchShape2 shape" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="shape" Type="PatternMatching.PatternMatchingExamples+Shape" /> + </Parameters> + <Docs> + <param name="shape">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="printColorName"> + <MemberSignature Language="C#" Value="public static void printColorName (PatternMatching.PatternMatchingExamples.Color color);" /> + <MemberSignature Language="ILAsm" Value=".method public static void printColorName(valuetype PatternMatching.PatternMatchingExamples/Color color) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.printColorName : PatternMatching.PatternMatchingExamples.Color -> unit" Usage="PatternMatching.PatternMatchingExamples.printColorName color" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="color" Type="PatternMatching.PatternMatchingExamples+Color" /> + </Parameters> + <Docs> + <param name="color">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="printList"> + <MemberSignature Language="C#" Value="public static void printList (Microsoft.FSharp.Collections.FSharpList<int> l);" /> + <MemberSignature Language="ILAsm" Value=".method public static void printList(class Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.printList : List<int> -> unit" Usage="PatternMatching.PatternMatchingExamples.printList l" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="l" Type="Microsoft.FSharp.Collections.FSharpList<System.Int32>" /> + </Parameters> + <Docs> + <param name="l">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="printOption"> + <MemberSignature Language="C#" Value="public static void printOption (Microsoft.FSharp.Core.FSharpOption<int> data);" /> + <MemberSignature Language="ILAsm" Value=".method public static void printOption(class Microsoft.FSharp.Core.FSharpOption`1<int32> data) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.printOption : option<int> -> unit" Usage="PatternMatching.PatternMatchingExamples.printOption data" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="data" Type="Microsoft.FSharp.Core.FSharpOption<System.Int32>" /> + </Parameters> + <Docs> + <param name="data">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ReadFromFile"> + <MemberSignature Language="C#" Value="public static bool ReadFromFile (System.IO.StreamReader reader);" /> + <MemberSignature Language="ILAsm" Value=".method public static bool ReadFromFile(class System.IO.StreamReader reader) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.ReadFromFile : System.IO.StreamReader -> bool" Usage="PatternMatching.PatternMatchingExamples.ReadFromFile reader" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="reader" Type="System.IO.StreamReader" /> + </Parameters> + <Docs> + <param name="reader">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="recordX"> + <MemberSignature Language="C#" Value="public static PatternMatching.PatternMatchingExamples.MyRecord recordX { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class PatternMatching.PatternMatchingExamples/MyRecord recordX" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.recordX : PatternMatching.PatternMatchingExamples.MyRecord" Usage="PatternMatching.PatternMatchingExamples.recordX" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>PatternMatching.PatternMatchingExamples+MyRecord</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="result"> + <MemberSignature Language="C#" Value="public static int result { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 result" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.result : int" Usage="PatternMatching.PatternMatchingExamples.result" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="sr"> + <MemberSignature Language="C#" Value="public static System.IO.StreamReader sr { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class System.IO.StreamReader sr" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.sr : System.IO.StreamReader" Usage="PatternMatching.PatternMatchingExamples.sr" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.IO.StreamReader</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Three"> + <MemberSignature Language="C#" Value="public const int Three = 3;" /> + <MemberSignature Language="ILAsm" Value=".field public static literal int32 Three = (3)" /> + <MemberSignature Language="F#" Value="val mutable Three : int" Usage="PatternMatching.PatternMatchingExamples.Three" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Literal</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <MemberValue>3</MemberValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="tuple1"> + <MemberSignature Language="C#" Value="public static Tuple<int,int> tuple1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class System.Tuple`2<int32, int32> tuple1" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.tuple1 : int * int" Usage="PatternMatching.PatternMatchingExamples.tuple1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Tuple<System.Int32,System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="var1"> + <MemberSignature Language="C#" Value="public static int var1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 var1" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.var1 : int" Usage="PatternMatching.PatternMatchingExamples.var1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="var2"> + <MemberSignature Language="C#" Value="public static int var2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 var2" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.var2 : int" Usage="PatternMatching.PatternMatchingExamples.var2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="vectorLength"> + <MemberSignature Language="C#" Value="public static double vectorLength (double[] vec);" /> + <MemberSignature Language="ILAsm" Value=".method public static float64 vectorLength(float64[] vec) cil managed" /> + <MemberSignature Language="F#" Value="PatternMatching.PatternMatchingExamples.vectorLength : double[] -> double" Usage="PatternMatching.PatternMatchingExamples.vectorLength vec" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="vec" Type="System.Double[]" /> + </Parameters> + <Docs> + <param name="vec">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Properties+MyAutoPropertyClass.xml b/mdoc/Test/en.expected-fsharp/Properties+MyAutoPropertyClass.xml new file mode 100644 index 00000000..50369d61 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Properties+MyAutoPropertyClass.xml @@ -0,0 +1,71 @@ +<Type Name="Properties+MyAutoPropertyClass" FullName="Properties+MyAutoPropertyClass"> + <TypeSignature Language="C#" Value="public class Properties.MyAutoPropertyClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Properties/MyAutoPropertyClass extends System.Object" /> + <TypeSignature Language="F#" Value="type Properties.MyAutoPropertyClass = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyAutoPropertyClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="AutoProperty"> + <MemberSignature Language="C#" Value="public int AutoProperty { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 AutoProperty" /> + <MemberSignature Language="F#" Value="member this.AutoProperty : int with get, set" Usage="Properties.MyAutoPropertyClass.AutoProperty" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ExplicitProperty"> + <MemberSignature Language="C#" Value="public int ExplicitProperty { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 ExplicitProperty" /> + <MemberSignature Language="F#" Value="member this.ExplicitProperty : int" Usage="Properties.MyAutoPropertyClass.ExplicitProperty" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Properties+MyPropertiesType.xml b/mdoc/Test/en.expected-fsharp/Properties+MyPropertiesType.xml new file mode 100644 index 00000000..5adae6ed --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Properties+MyPropertiesType.xml @@ -0,0 +1,88 @@ +<Type Name="Properties+MyPropertiesType" FullName="Properties+MyPropertiesType"> + <TypeSignature Language="C#" Value="public class Properties.MyPropertiesType" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Properties/MyPropertiesType extends System.Object" /> + <TypeSignature Language="F#" Value="type Properties.MyPropertiesType = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyPropertiesType ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="MyReadOnlyProperty"> + <MemberSignature Language="C#" Value="public int MyReadOnlyProperty { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 MyReadOnlyProperty" /> + <MemberSignature Language="F#" Value="member this.MyReadOnlyProperty : int" Usage="Properties.MyPropertiesType.MyReadOnlyProperty" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="MyReadWriteProperty"> + <MemberSignature Language="C#" Value="public int MyReadWriteProperty { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 MyReadWriteProperty" /> + <MemberSignature Language="F#" Value="member this.MyReadWriteProperty : int with get, set" Usage="Properties.MyPropertiesType.MyReadWriteProperty" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="MyWriteOnlyProperty"> + <MemberSignature Language="C#" Value="public int MyWriteOnlyProperty { set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 MyWriteOnlyProperty" /> + <MemberSignature Language="F#" Value="member this.MyWriteOnlyProperty : int" Usage="Properties.MyPropertiesType.MyWriteOnlyProperty" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Properties+MyPropertyClass2.xml b/mdoc/Test/en.expected-fsharp/Properties+MyPropertyClass2.xml new file mode 100644 index 00000000..d5d9d428 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Properties+MyPropertyClass2.xml @@ -0,0 +1,75 @@ +<Type Name="Properties+MyPropertyClass2" FullName="Properties+MyPropertyClass2"> + <TypeSignature Language="C#" Value="public class Properties.MyPropertyClass2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable Properties/MyPropertyClass2 extends System.Object" /> + <TypeSignature Language="F#" Value="type Properties.MyPropertyClass2 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyPropertyClass2 (int property1);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 property1) cil managed" /> + <MemberSignature Language="F#" Value="new Properties.MyPropertyClass2 : int -> Properties.MyPropertyClass2" Usage="new Properties.MyPropertyClass2 property1" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="property1" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="property1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Property1"> + <MemberSignature Language="C#" Value="public int Property1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Property1" /> + <MemberSignature Language="F#" Value="member this.Property1 : int" Usage="Properties.MyPropertyClass2.Property1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Property2"> + <MemberSignature Language="C#" Value="public string Property2 { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Property2" /> + <MemberSignature Language="F#" Value="member this.Property2 : string with get, set" Usage="Properties.MyPropertyClass2.Property2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Properties.xml b/mdoc/Test/en.expected-fsharp/Properties.xml new file mode 100644 index 00000000..31dd26d1 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Properties.xml @@ -0,0 +1,23 @@ +<Type Name="Properties" FullName="Properties"> + <TypeSignature Language="C#" Value="public static class Properties" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Properties extends System.Object" /> + <TypeSignature Language="F#" Value="module Properties" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Records+Car.xml b/mdoc/Test/en.expected-fsharp/Records+Car.xml new file mode 100644 index 00000000..7f847ab5 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Records+Car.xml @@ -0,0 +1,326 @@ +<Type Name="Records+Car" FullName="Records+Car"> + <TypeSignature Language="C#" Value="public sealed class Records.Car : IComparable, IComparable<Records.Car>, IEquatable<Records.Car>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Records/Car extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Records/Car>, class System.IEquatable`1<Records/Car>" /> + <TypeSignature Language="F#" Value="type Records.Car = {}" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Records+Car></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Records+Car></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.RecordType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Car (string make, string model, int odometer);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(string make, string model, int32 odometer) cil managed" /> + <MemberSignature Language="F#" Value="new Records.Car : string * string * int -> Records.Car" Usage="new Records.Car (make, model, odometer)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="make" Type="System.String" /> + <Parameter Name="model" Type="System.String" /> + <Parameter Name="odometer" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="make">To be added.</param> + <param name="model">To be added.</param> + <param name="odometer">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Records.Car obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Records/Car obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Records+Car" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Records.Car obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Records/Car obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Records+Car" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Make"> + <MemberSignature Language="C#" Value="public string Make { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Make" /> + <MemberSignature Language="F#" Value="Make : string" Usage="Records.Car.Make" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Model"> + <MemberSignature Language="C#" Value="public string Model { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string Model" /> + <MemberSignature Language="F#" Value="Model : string" Usage="Records.Car.Model" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Odometer"> + <MemberSignature Language="C#" Value="public int Odometer { get; set; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Odometer" /> + <MemberSignature Language="F#" Value="mutable Odometer : int" Usage="Records.Car.Odometer" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Odometer@"> + <MemberSignature Language="C#" Value="public int Odometer@;" /> + <MemberSignature Language="ILAsm" Value=".field public int32 Odometer@" /> + <MemberSignature Language="F#" Value="val mutable Odometer@ : int" Usage="Records.Car.Odometer@" /> + <MemberType>Field</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Records+MyRecord.xml b/mdoc/Test/en.expected-fsharp/Records+MyRecord.xml new file mode 100644 index 00000000..7364d3eb --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Records+MyRecord.xml @@ -0,0 +1,305 @@ +<Type Name="Records+MyRecord" FullName="Records+MyRecord"> + <TypeSignature Language="C#" Value="public sealed class Records.MyRecord : IComparable, IComparable<Records.MyRecord>, IEquatable<Records.MyRecord>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed Records/MyRecord extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Records/MyRecord>, class System.IEquatable`1<Records/MyRecord>" /> + <TypeSignature Language="F#" Value="type Records.MyRecord = {}" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Records+MyRecord></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Records+MyRecord></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.RecordType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyRecord (int x, int y, int z);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(int32 x, int32 y, int32 z) cil managed" /> + <MemberSignature Language="F#" Value="new Records.MyRecord : int * int * int -> Records.MyRecord" Usage="new Records.MyRecord (x, y, z)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Int32" /> + <Parameter Name="y" Type="System.Int32" /> + <Parameter Name="z" Type="System.Int32" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="z">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Records.MyRecord obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Records/MyRecord obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Records+MyRecord" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Records.MyRecord obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Records/MyRecord obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Records+MyRecord" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public int X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 X" /> + <MemberSignature Language="F#" Value="X : int" Usage="Records.MyRecord.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public int Y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Y" /> + <MemberSignature Language="F#" Value="Y : int" Usage="Records.MyRecord.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Z"> + <MemberSignature Language="C#" Value="public int Z { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance int32 Z" /> + <MemberSignature Language="F#" Value="Z : int" Usage="Records.MyRecord.Z" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Records.xml b/mdoc/Test/en.expected-fsharp/Records.xml new file mode 100644 index 00000000..17a6d8ff --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Records.xml @@ -0,0 +1,68 @@ +<Type Name="Records" FullName="Records"> + <TypeSignature Language="C#" Value="public static class Records" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Records extends System.Object" /> + <TypeSignature Language="F#" Value="module Records" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="myCar"> + <MemberSignature Language="C#" Value="public static Records.Car myCar { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Records/Car myCar" /> + <MemberSignature Language="F#" Value="Records.myCar : Records.Car" Usage="Records.myCar" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Records+Car</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="myRecord1"> + <MemberSignature Language="C#" Value="public static Records.MyRecord myRecord1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property Records/MyRecord myRecord1" /> + <MemberSignature Language="F#" Value="Records.myRecord1 : Records.MyRecord" Usage="Records.myRecord1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Records+MyRecord</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/ReferenceCells.xml b/mdoc/Test/en.expected-fsharp/ReferenceCells.xml new file mode 100644 index 00000000..f3d32e17 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ReferenceCells.xml @@ -0,0 +1,46 @@ +<Type Name="ReferenceCells" FullName="ReferenceCells"> + <TypeSignature Language="C#" Value="public static class ReferenceCells" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed ReferenceCells extends System.Object" /> + <TypeSignature Language="F#" Value="module ReferenceCells" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="refVar"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Core.FSharpRef<int> refVar { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Core.FSharpRef`1<int32> refVar" /> + <MemberSignature Language="F#" Value="ReferenceCells.refVar : ref<int>" Usage="ReferenceCells.refVar" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpRef<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+IVector.xml b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+IVector.xml new file mode 100644 index 00000000..7c4b8315 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+IVector.xml @@ -0,0 +1,42 @@ +<Type Name="SomeModule+IVector" FullName="SomeNamespace.SomeModule+IVector"> + <TypeSignature Language="C#" Value="public interface SomeModule.IVector" /> + <TypeSignature Language="ILAsm" Value=".class nested public interface auto ansi abstract serializable SomeModule/IVector" /> + <TypeSignature Language="F#" Value="type SomeModule.IVector = interface" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="Scale"> + <MemberSignature Language="C#" Value="public SomeNamespace.SomeModule.IVector Scale (double );" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance class SomeNamespace.SomeModule/IVector Scale(float64 ) cil managed" /> + <MemberSignature Language="F#" Value="abstract member Scale : double -> SomeNamespace.SomeModule.IVector" Usage="iVector.Scale " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>SomeNamespace.SomeModule+IVector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="" Type="System.Double" /> + </Parameters> + <Docs> + <param name="">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector'''.xml b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector'''.xml new file mode 100644 index 00000000..64801bbe --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector'''.xml @@ -0,0 +1,81 @@ +<Type Name="SomeModule+Vector'''" FullName="SomeNamespace.SomeModule+Vector'''"> + <TypeSignature Language="C#" Value="public class SomeModule.Vector''' : SomeNamespace.SomeModule.IVector" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable SomeModule/Vector''' extends System.Object implements class SomeNamespace.SomeModule/IVector" /> + <TypeSignature Language="F#" Value="type SomeModule.Vector''' = class
 interface SomeModule.IVector" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>SomeNamespace.SomeModule+IVector</InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Vector''' (double x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new SomeNamespace.SomeModule.Vector''' : double * double -> SomeNamespace.SomeModule.Vector'''" Usage="new SomeNamespace.SomeModule.Vector''' (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public double X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 X" /> + <MemberSignature Language="F#" Value="member this.X : double" Usage="SomeNamespace.SomeModule.Vector'''.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public double Y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Y" /> + <MemberSignature Language="F#" Value="member this.Y : double" Usage="SomeNamespace.SomeModule.Vector'''.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector.xml b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector.xml new file mode 100644 index 00000000..291515c6 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector.xml @@ -0,0 +1,138 @@ +<Type Name="SomeModule+Vector" FullName="SomeNamespace.SomeModule+Vector"> + <TypeSignature Language="C#" Value="public class SomeModule.Vector" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable SomeModule/Vector extends System.Object" /> + <TypeSignature Language="F#" Value="type SomeModule.Vector = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Vector (double x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new SomeNamespace.SomeModule.Vector : double * double -> SomeNamespace.SomeModule.Vector" Usage="new SomeNamespace.SomeModule.Vector (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Mag"> + <MemberSignature Language="C#" Value="public double Mag { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Mag" /> + <MemberSignature Language="F#" Value="member this.Mag : double" Usage="SomeNamespace.SomeModule.Vector.Mag" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="op_Addition"> + <MemberSignature Language="C#" Value="public static SomeNamespace.SomeModule.Vector operator + (SomeNamespace.SomeModule.Vector a, SomeNamespace.SomeModule.Vector b);" /> + <MemberSignature Language="ILAsm" Value=".method public static specialname class SomeNamespace.SomeModule/Vector op_Addition(class SomeNamespace.SomeModule/Vector a, class SomeNamespace.SomeModule/Vector b) cil managed" /> + <MemberSignature Language="F#" Value="static member ( + ) : SomeNamespace.SomeModule.Vector * SomeNamespace.SomeModule.Vector -> SomeNamespace.SomeModule.Vector" Usage="a + b" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>SomeNamespace.SomeModule+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="a" Type="SomeNamespace.SomeModule+Vector" /> + <Parameter Name="b" Type="SomeNamespace.SomeModule+Vector" /> + </Parameters> + <Docs> + <param name="a">To be added.</param> + <param name="b">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Scale"> + <MemberSignature Language="C#" Value="public SomeNamespace.SomeModule.Vector Scale (double s);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class SomeNamespace.SomeModule/Vector Scale(float64 s) cil managed" /> + <MemberSignature Language="F#" Value="member this.Scale : double -> SomeNamespace.SomeModule.Vector" Usage="vector.Scale s" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>SomeNamespace.SomeModule+Vector</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="s" Type="System.Double" /> + </Parameters> + <Docs> + <param name="s">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public double X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 X" /> + <MemberSignature Language="F#" Value="member this.X : double" Usage="SomeNamespace.SomeModule.Vector.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public double Y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Y" /> + <MemberSignature Language="F#" Value="member this.Y : double" Usage="SomeNamespace.SomeModule.Vector.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector2.xml b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector2.xml new file mode 100644 index 00000000..ae1f6577 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule+Vector2.xml @@ -0,0 +1,81 @@ +<Type Name="SomeModule+Vector2" FullName="SomeNamespace.SomeModule+Vector2"> + <TypeSignature Language="C#" Value="public class SomeModule.Vector2 : SomeNamespace.SomeModule.IVector" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable SomeModule/Vector2 extends System.Object implements class SomeNamespace.SomeModule/IVector" /> + <TypeSignature Language="F#" Value="type SomeModule.Vector2 = class
 interface SomeModule.IVector" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>SomeNamespace.SomeModule+IVector</InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Vector2 (double x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new SomeNamespace.SomeModule.Vector2 : double * double -> SomeNamespace.SomeModule.Vector2" Usage="new SomeNamespace.SomeModule.Vector2 (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public double X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 X" /> + <MemberSignature Language="F#" Value="member this.X : double" Usage="SomeNamespace.SomeModule.Vector2.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public double Y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Y" /> + <MemberSignature Language="F#" Value="member this.Y : double" Usage="SomeNamespace.SomeModule.Vector2.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule.xml b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule.xml new file mode 100644 index 00000000..72270c0e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/SomeNamespace/SomeModule.xml @@ -0,0 +1,23 @@ +<Type Name="SomeModule" FullName="SomeNamespace.SomeModule"> + <TypeSignature Language="C#" Value="public static class SomeModule" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed SomeModule extends System.Object" /> + <TypeSignature Language="F#" Value="module Some" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Structures+Point2D.xml b/mdoc/Test/en.expected-fsharp/Structures+Point2D.xml new file mode 100644 index 00000000..2dcd8ac1 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Structures+Point2D.xml @@ -0,0 +1,264 @@ +<Type Name="Structures+Point2D" FullName="Structures+Point2D"> + <TypeSignature Language="C#" Value="public struct Structures.Point2D : IComparable, IComparable<Structures.Point2D>, IEquatable<Structures.Point2D>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Structures/Point2D extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Structures/Point2D>, class System.IEquatable`1<Structures/Point2D>" /> + <TypeSignature Language="F#" Value="type Structures.Point2D = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Structures+Point2D></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Structures+Point2D></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Point2D (double x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="new Structures.Point2D : double * double -> Structures.Point2D" Usage="new Structures.Point2D (x, y)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Structures.Point2D obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Structures/Point2D obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+Point2D" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Structures.Point2D obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Structures/Point2D obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+Point2D" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public double X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 X" /> + <MemberSignature Language="F#" Value="val X : double" Usage="Structures.Point2D.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Y"> + <MemberSignature Language="C#" Value="public double Y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 Y" /> + <MemberSignature Language="F#" Value="val Y : double" Usage="Structures.Point2D.Y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Structures+Point3D.xml b/mdoc/Test/en.expected-fsharp/Structures+Point3D.xml new file mode 100644 index 00000000..4b742c8e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Structures+Point3D.xml @@ -0,0 +1,267 @@ +<Type Name="Structures+Point3D" FullName="Structures+Point3D"> + <TypeSignature Language="C#" Value="public struct Structures.Point3D : IComparable, IComparable<Structures.Point3D>, IEquatable<Structures.Point3D>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Structures/Point3D extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Structures/Point3D>, class System.IEquatable`1<Structures/Point3D>" /> + <TypeSignature Language="F#" Value="type Structures.Point3D = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Structures+Point3D></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Structures+Point3D></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Structures.Point3D obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Structures/Point3D obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+Point3D" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Structures.Point3D obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Structures/Point3D obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+Point3D" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x"> + <MemberSignature Language="C#" Value="public double x { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 x" /> + <MemberSignature Language="F#" Value="val x : double" Usage="Structures.Point3D.x" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="y"> + <MemberSignature Language="C#" Value="public double y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 y" /> + <MemberSignature Language="F#" Value="val y : double" Usage="Structures.Point3D.y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="z"> + <MemberSignature Language="C#" Value="public double z { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 z" /> + <MemberSignature Language="F#" Value="val z : double" Usage="Structures.Point3D.z" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Structures+StructureType.xml b/mdoc/Test/en.expected-fsharp/Structures+StructureType.xml new file mode 100644 index 00000000..6c380f0d --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Structures+StructureType.xml @@ -0,0 +1,223 @@ +<Type Name="Structures+StructureType" FullName="Structures+StructureType"> + <TypeSignature Language="C#" Value="public struct Structures.StructureType : IComparable, IComparable<Structures.StructureType>, IEquatable<Structures.StructureType>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Structures/StructureType extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Structures/StructureType>, class System.IEquatable`1<Structures/StructureType>" /> + <TypeSignature Language="F#" Value="type Structures.StructureType = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Structures+StructureType></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Structures+StructureType></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Structures.StructureType obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Structures/StructureType obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+StructureType" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Structures.StructureType obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Structures/StructureType obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+StructureType" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x"> + <MemberSignature Language="C#" Value="public double x { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 x" /> + <MemberSignature Language="F#" Value="val x : double" Usage="Structures.StructureType.x" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Structures+StructureType2.xml b/mdoc/Test/en.expected-fsharp/Structures+StructureType2.xml new file mode 100644 index 00000000..e4c6fad4 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Structures+StructureType2.xml @@ -0,0 +1,226 @@ +<Type Name="Structures+StructureType2" FullName="Structures+StructureType2"> + <TypeSignature Language="C#" Value="public struct Structures.StructureType2 : IComparable, IComparable<Structures.StructureType2>, IEquatable<Structures.StructureType2>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public sequential ansi serializable sealed Structures/StructureType2 extends System.ValueType implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<Structures/StructureType2>, class System.IEquatable`1<Structures/StructureType2>" /> + <TypeSignature Language="F#" Value="type Structures.StructureType2 = struct" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.ValueType</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<Structures+StructureType2></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<Structures+StructureType2></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Struct</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (Structures.StructureType2 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(Structures/StructureType2 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+StructureType2" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (Structures.StructureType2 obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(Structures/StructureType2 obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="Structures+StructureType2" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x"> + <MemberSignature Language="C#" Value="public double x { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 x" /> + <MemberSignature Language="F#" Value="val x : double" Usage="Structures.StructureType2.x" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Structures.xml b/mdoc/Test/en.expected-fsharp/Structures.xml new file mode 100644 index 00000000..debd4661 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Structures.xml @@ -0,0 +1,23 @@ +<Type Name="Structures" FullName="Structures"> + <TypeSignature Language="C#" Value="public static class Structures" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed Structures extends System.Object" /> + <TypeSignature Language="F#" Value="module Structures" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/TypeExtensions+ExtraCSharpStyleExtensionMethodsInFSharp.xml b/mdoc/Test/en.expected-fsharp/TypeExtensions+ExtraCSharpStyleExtensionMethodsInFSharp.xml new file mode 100644 index 00000000..f399e326 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/TypeExtensions+ExtraCSharpStyleExtensionMethodsInFSharp.xml @@ -0,0 +1,62 @@ +<Type Name="TypeExtensions+ExtraCSharpStyleExtensionMethodsInFSharp" FullName="TypeExtensions+ExtraCSharpStyleExtensionMethodsInFSharp"> + <TypeSignature Language="C#" Value="public class TypeExtensions.ExtraCSharpStyleExtensionMethodsInFSharp" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable TypeExtensions/ExtraCSharpStyleExtensionMethodsInFSharp extends System.Object" /> + <TypeSignature Language="F#" Value="type TypeExtensions.ExtraCSharpStyleExtensionMethodsInFSharp = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public ExtraCSharpStyleExtensionMethodsInFSharp ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Sum<T>"> + <MemberSignature Language="C#" Value="public static T Sum<T> (this System.Collections.Generic.IEnumerable<T> xs);" /> + <MemberSignature Language="ILAsm" Value=".method public static !!T Sum<T>(class System.Collections.Generic.IEnumerable`1<!!T> xs) cil managed" /> + <MemberSignature Language="F#" Value="static member Sum : seq<'T> -> 'T" Usage="TypeExtensions.ExtraCSharpStyleExtensionMethodsInFSharp.Sum xs" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>T</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Parameters> + <Parameter Name="xs" Type="System.Collections.Generic.IEnumerable<T>" RefType="this" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="xs">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions1+MyClass.xml b/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions1+MyClass.xml new file mode 100644 index 00000000..9b70f514 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions1+MyClass.xml @@ -0,0 +1,73 @@ +<Type Name="TypeExtensions+TypeExtensions1+MyClass" FullName="TypeExtensions+TypeExtensions1+MyClass"> + <TypeSignature Language="C#" Value="public class TypeExtensions.TypeExtensions1.MyClass" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable TypeExtensions/TypeExtensions1/MyClass extends System.Object" /> + <TypeSignature Language="F#" Value="type TypeExtensions.TypeExtensions1.MyClass = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public MyClass ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="F"> + <MemberSignature Language="C#" Value="public int F ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 F() cil managed" /> + <MemberSignature Language="F#" Value="member this.F : unit -> int" Usage="myClass.F " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="G"> + <MemberSignature Language="C#" Value="public int G ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 G() cil managed" /> + <MemberSignature Language="F#" Value="member this.G : unit -> int" Usage="myClass.G " /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions1.xml b/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions1.xml new file mode 100644 index 00000000..854219dd --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions1.xml @@ -0,0 +1,23 @@ +<Type Name="TypeExtensions+TypeExtensions1" FullName="TypeExtensions+TypeExtensions1"> + <TypeSignature Language="C#" Value="public static class TypeExtensions.TypeExtensions1" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed TypeExtensions/TypeExtensions1 extends System.Object" /> + <TypeSignature Language="F#" Value="module TypeExtensions.TypeExtensions1" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions2.xml b/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions2.xml new file mode 100644 index 00000000..af7dbac6 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/TypeExtensions+TypeExtensions2.xml @@ -0,0 +1,44 @@ +<Type Name="TypeExtensions+TypeExtensions2" FullName="TypeExtensions+TypeExtensions2"> + <TypeSignature Language="C#" Value="public static class TypeExtensions.TypeExtensions2" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi abstract sealed TypeExtensions/TypeExtensions2 extends System.Object" /> + <TypeSignature Language="F#" Value="module TypeExtensions.TypeExtensions2" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="function1"> + <MemberSignature Language="C#" Value="public static void function1 (TypeExtensions.TypeExtensions1.MyClass obj1);" /> + <MemberSignature Language="ILAsm" Value=".method public static void function1(TypeExtensions/TypeExtensions1/MyClass obj1) cil managed" /> + <MemberSignature Language="F#" Value="TypeExtensions.TypeExtensions2.function1 : TypeExtensions.TypeExtensions1.MyClass -> unit" Usage="TypeExtensions.TypeExtensions2.function1 obj1" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj1" Type="TypeExtensions+TypeExtensions1+MyClass" /> + </Parameters> + <Docs> + <param name="obj1">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/TypeExtensions.xml b/mdoc/Test/en.expected-fsharp/TypeExtensions.xml new file mode 100644 index 00000000..b0244162 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/TypeExtensions.xml @@ -0,0 +1,192 @@ +<Type Name="TypeExtensions" FullName="TypeExtensions"> + <TypeSignature Language="C#" Value="public static class TypeExtensions" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed TypeExtensions extends System.Object" /> + <TypeSignature Language="F#" Value="module TypeExtensions" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="IEnumerable`1.RepeatElements<T>"> + <MemberSignature Language="C#" Value="public static System.Collections.Generic.IEnumerable<T> IEnumerable`1.RepeatElements<T> (System.Collections.Generic.IEnumerable<T> xs, int n);" /> + <MemberSignature Language="ILAsm" Value=".method public static class System.Collections.Generic.IEnumerable`1<!!T> IEnumerable`1.RepeatElements<T>(class System.Collections.Generic.IEnumerable`1<!!T> xs, int32 n) cil managed" /> + <MemberSignature Language="F#" Value="TypeExtensions.IEnumerable`1.RepeatElements : seq<'T> -> int -> seq<'T>" Usage="TypeExtensions.IEnumerable`1.RepeatElements xs n" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Collections.Generic.IEnumerable<T></ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Parameters> + <Parameter Name="xs" Type="System.Collections.Generic.IEnumerable<T>" /> + <Parameter Name="n" Type="System.Int32" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="xs">To be added.</param> + <param name="n">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Int32.FromString"> + <MemberSignature Language="C#" Value="public static int Int32.FromString (int this, string s);" /> + <MemberSignature Language="ILAsm" Value=".method public static int32 Int32.FromString(int32 this, string s) cil managed" /> + <MemberSignature Language="F#" Value="TypeExtensions.Int32.FromString : string -> int" Usage="TypeExtensions.Int32.FromString s" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="this" Type="System.Int32" /> + <Parameter Name="s" Type="System.String" /> + </Parameters> + <Docs> + <param name="this">To be added.</param> + <param name="s">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="listOfBigIntegers"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Collections.FSharpList<System.Numerics.BigInteger> listOfBigIntegers { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Collections.FSharpList`1<valuetype System.Numerics.BigInteger> listOfBigIntegers" /> + <MemberSignature Language="F#" Value="TypeExtensions.listOfBigIntegers : List<System.Numerics.BigInteger>" Usage="TypeExtensions.listOfBigIntegers" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Collections.FSharpList<System.Numerics.BigInteger></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="listOfIntegers"> + <MemberSignature Language="C#" Value="public static Microsoft.FSharp.Collections.FSharpList<int> listOfIntegers { get; }" /> + <MemberSignature Language="ILAsm" Value=".property class Microsoft.FSharp.Collections.FSharpList`1<int32> listOfIntegers" /> + <MemberSignature Language="F#" Value="TypeExtensions.listOfIntegers : List<int>" Usage="TypeExtensions.listOfIntegers" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Collections.FSharpList<System.Int32></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="sum1"> + <MemberSignature Language="C#" Value="public static int sum1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property int32 sum1" /> + <MemberSignature Language="F#" Value="TypeExtensions.sum1 : int" Usage="TypeExtensions.sum1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="sum2"> + <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger sum2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property valuetype System.Numerics.BigInteger sum2" /> + <MemberSignature Language="F#" Value="TypeExtensions.sum2 : System.Numerics.BigInteger" Usage="TypeExtensions.sum2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Numerics.BigInteger</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="testFromString"> + <MemberSignature Language="C#" Value="public static void testFromString (string str);" /> + <MemberSignature Language="ILAsm" Value=".method public static void testFromString(string str) cil managed" /> + <MemberSignature Language="F#" Value="TypeExtensions.testFromString : string -> unit" Usage="TypeExtensions.testFromString str" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Void</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="str" Type="System.String" /> + </Parameters> + <Docs> + <param name="str">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+L.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+L.xml new file mode 100644 index 00000000..86a64424 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+L.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+L" FullName="UnitsOfMeasure+L"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.L" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/L extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.L = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+bar.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+bar.xml new file mode 100644 index 00000000..4c683035 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+bar.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+bar" FullName="UnitsOfMeasure+bar"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.bar" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/bar extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.bar = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+cm.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+cm.xml new file mode 100644 index 00000000..936e7347 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+cm.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+cm" FullName="UnitsOfMeasure+cm"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.cm" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/cm extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.cm = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+ft.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+ft.xml new file mode 100644 index 00000000..fbb679b1 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+ft.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+ft" FullName="UnitsOfMeasure+ft"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.ft" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/ft extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.ft = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+g.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+g.xml new file mode 100644 index 00000000..c2b5c5b8 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+g.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+g" FullName="UnitsOfMeasure+g"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.g" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/g extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.g = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+inch.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+inch.xml new file mode 100644 index 00000000..6799339e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+inch.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+inch" FullName="UnitsOfMeasure+inch"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.inch" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/inch extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.inch = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+kg.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+kg.xml new file mode 100644 index 00000000..360ac174 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+kg.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+kg" FullName="UnitsOfMeasure+kg"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.kg" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/kg extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.kg = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+lb.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+lb.xml new file mode 100644 index 00000000..2a57827d --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+lb.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+lb" FullName="UnitsOfMeasure+lb"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.lb" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/lb extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.lb = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+m.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+m.xml new file mode 100644 index 00000000..13b717cc --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+m.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+m" FullName="UnitsOfMeasure+m"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.m" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/m extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.m = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+s.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+s.xml new file mode 100644 index 00000000..48c7f649 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+s.xml @@ -0,0 +1,26 @@ +<Type Name="UnitsOfMeasure+s" FullName="UnitsOfMeasure+s"> + <TypeSignature Language="C#" Value="public class UnitsOfMeasure.s" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable UnitsOfMeasure/s extends System.Object" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.s = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.Measure</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members /> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+vector3D.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+vector3D.xml new file mode 100644 index 00000000..b3551eb3 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure+vector3D.xml @@ -0,0 +1,305 @@ +<Type Name="UnitsOfMeasure+vector3D" FullName="UnitsOfMeasure+vector3D"> + <TypeSignature Language="C#" Value="public sealed class UnitsOfMeasure.vector3D : IComparable, IComparable<UnitsOfMeasure.vector3D>, IEquatable<UnitsOfMeasure.vector3D>, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable" /> + <TypeSignature Language="ILAsm" Value=".class nested public auto ansi serializable sealed beforefieldinit UnitsOfMeasure/vector3D extends System.Object implements class System.Collections.IStructuralComparable, class System.Collections.IStructuralEquatable, class System.IComparable, class System.IComparable`1<UnitsOfMeasure/vector3D>, class System.IEquatable`1<UnitsOfMeasure/vector3D>" /> + <TypeSignature Language="F#" Value="type UnitsOfMeasure.vector3D = {}" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces> + <Interface> + <InterfaceName>System.Collections.IStructuralComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.Collections.IStructuralEquatable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable</InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IComparable<UnitsOfMeasure+vector3D></InterfaceName> + </Interface> + <Interface> + <InterfaceName>System.IEquatable<UnitsOfMeasure+vector3D></InterfaceName> + </Interface> + </Interfaces> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.RecordType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public vector3D (double x, double y, double z);" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor(float64 x, float64 y, float64 z) cil managed" /> + <MemberSignature Language="F#" Value="new UnitsOfMeasure.vector3D : double * double * double -> UnitsOfMeasure.vector3D" Usage="new UnitsOfMeasure.vector3D (x, y, z)" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + <Parameter Name="z" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <param name="z">To be added.</param> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (UnitsOfMeasure.vector3D obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(UnitsOfMeasure/vector3D obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="UnitsOfMeasure+vector3D" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="CompareTo"> + <MemberSignature Language="C#" Value="public override sealed int CompareTo (object obj, System.Collections.IComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 CompareTo(object obj, class System.Collections.IComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (UnitsOfMeasure.vector3D obj);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(UnitsOfMeasure/vector3D obj) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="UnitsOfMeasure+vector3D" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="Equals"> + <MemberSignature Language="C#" Value="public override sealed bool Equals (object obj, System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj, class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Boolean</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="obj" Type="System.Object" /> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="obj">To be added.</param> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode ();" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="GetHashCode"> + <MemberSignature Language="C#" Value="public override sealed int GetHashCode (System.Collections.IEqualityComparer comp);" /> + <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode(class System.Collections.IEqualityComparer comp) cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Int32</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="comp" Type="System.Collections.IEqualityComparer" /> + </Parameters> + <Docs> + <param name="comp">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ToString"> + <MemberSignature Language="C#" Value="public override string ToString ();" /> + <MemberSignature Language="ILAsm" Value=".method public virtual instance string ToString() cil managed" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x"> + <MemberSignature Language="C#" Value="public double x { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 x" /> + <MemberSignature Language="F#" Value="x : double" Usage="UnitsOfMeasure.vector3D.x" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 0)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="y"> + <MemberSignature Language="C#" Value="public double y { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 y" /> + <MemberSignature Language="F#" Value="y : double" Usage="UnitsOfMeasure.vector3D.y" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 1)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="z"> + <MemberSignature Language="C#" Value="public double z { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 z" /> + <MemberSignature Language="F#" Value="z : double" Usage="UnitsOfMeasure.vector3D.z" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Field, 2)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/UnitsOfMeasure.xml b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure.xml new file mode 100644 index 00000000..a2eb6a4d --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/UnitsOfMeasure.xml @@ -0,0 +1,358 @@ +<Type Name="UnitsOfMeasure" FullName="UnitsOfMeasure"> + <TypeSignature Language="C#" Value="public static class UnitsOfMeasure" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed UnitsOfMeasure extends System.Object" /> + <TypeSignature Language="F#" Value="module UnitsOfMeasure" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="cmPerInch"> + <MemberSignature Language="C#" Value="public static double cmPerInch { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 cmPerInch" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.cmPerInch : double" Usage="UnitsOfMeasure.cmPerInch" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="cmPerMeter"> + <MemberSignature Language="C#" Value="public static double cmPerMeter { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 cmPerMeter" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.cmPerMeter : double" Usage="UnitsOfMeasure.cmPerMeter" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="convertCentimetersToInches"> + <MemberSignature Language="C#" Value="public static double convertCentimetersToInches (double x);" /> + <MemberSignature Language="ILAsm" Value=".method public static float64 convertCentimetersToInches(float64 x) cil managed" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.convertCentimetersToInches : double -> double" Usage="UnitsOfMeasure.convertCentimetersToInches x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="convertGramsToKilograms"> + <MemberSignature Language="C#" Value="public static double convertGramsToKilograms (double x);" /> + <MemberSignature Language="ILAsm" Value=".method public static float64 convertGramsToKilograms(float64 x) cil managed" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.convertGramsToKilograms : double -> double" Usage="UnitsOfMeasure.convertGramsToKilograms x" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="genericSumUnits"> + <MemberSignature Language="C#" Value="public static double genericSumUnits (double x, double y);" /> + <MemberSignature Language="ILAsm" Value=".method public static float64 genericSumUnits(float64 x, float64 y) cil managed" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.genericSumUnits : double -> double -> double" Usage="UnitsOfMeasure.genericSumUnits x y" /> + <MemberType>Method</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Parameters> + <Parameter Name="x" Type="System.Double" /> + <Parameter Name="y" Type="System.Double" /> + </Parameters> + <Docs> + <param name="x">To be added.</param> + <param name="y">To be added.</param> + <summary>To be added.</summary> + <returns>To be added.</returns> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="gramsPerKilogram"> + <MemberSignature Language="C#" Value="public static double gramsPerKilogram { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 gramsPerKilogram" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.gramsPerKilogram : double" Usage="UnitsOfMeasure.gramsPerKilogram" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="mlPerCubicCentimeter"> + <MemberSignature Language="C#" Value="public static double mlPerCubicCentimeter { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 mlPerCubicCentimeter" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.mlPerCubicCentimeter : double" Usage="UnitsOfMeasure.mlPerCubicCentimeter" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="mlPerLiter"> + <MemberSignature Language="C#" Value="public static double mlPerLiter { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 mlPerLiter" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.mlPerLiter : double" Usage="UnitsOfMeasure.mlPerLiter" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="result1"> + <MemberSignature Language="C#" Value="public static double result1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 result1" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.result1 : double" Usage="UnitsOfMeasure.result1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="t1"> + <MemberSignature Language="C#" Value="public static double t1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 t1" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.t1 : double" Usage="UnitsOfMeasure.t1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v1"> + <MemberSignature Language="C#" Value="public static double v1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 v1" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.v1 : double" Usage="UnitsOfMeasure.v1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v1vec"> + <MemberSignature Language="C#" Value="public static UnitsOfMeasure.vector3D v1vec { get; }" /> + <MemberSignature Language="ILAsm" Value=".property UnitsOfMeasure/vector3D v1vec" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.v1vec : UnitsOfMeasure.vector3D" Usage="UnitsOfMeasure.v1vec" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>UnitsOfMeasure+vector3D</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="v2"> + <MemberSignature Language="C#" Value="public static double v2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 v2" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.v2 : double" Usage="UnitsOfMeasure.v2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="x1"> + <MemberSignature Language="C#" Value="public static double x1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property float64 x1" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.x1 : double" Usage="UnitsOfMeasure.x1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="xvec"> + <MemberSignature Language="C#" Value="public static UnitsOfMeasure.vector3D xvec { get; }" /> + <MemberSignature Language="ILAsm" Value=".property UnitsOfMeasure/vector3D xvec" /> + <MemberSignature Language="F#" Value="UnitsOfMeasure.xvec : UnitsOfMeasure.vector3D" Usage="UnitsOfMeasure.xvec" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Value)</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>UnitsOfMeasure+vector3D</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Widgets/MyWidget1.xml b/mdoc/Test/en.expected-fsharp/Widgets/MyWidget1.xml new file mode 100644 index 00000000..938dee7c --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Widgets/MyWidget1.xml @@ -0,0 +1,41 @@ +<Type Name="MyWidget1" FullName="Widgets.MyWidget1"> + <TypeSignature Language="C#" Value="public class MyWidget1" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi serializable MyWidget1 extends System.Object" /> + <TypeSignature Language="F#" Value="type MyWidget1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="WidgetName"> + <MemberSignature Language="C#" Value="public string WidgetName { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string WidgetName" /> + <MemberSignature Language="F#" Value="member this.WidgetName : string" Usage="Widgets.MyWidget1.WidgetName" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/Widgets/WidgetsModule.xml b/mdoc/Test/en.expected-fsharp/Widgets/WidgetsModule.xml new file mode 100644 index 00000000..9acb440e --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/Widgets/WidgetsModule.xml @@ -0,0 +1,46 @@ +<Type Name="WidgetsModule" FullName="Widgets.WidgetsModule"> + <TypeSignature Language="C#" Value="public static class WidgetsModule" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed WidgetsModule extends System.Object" /> + <TypeSignature Language="F#" Value="module Widgets" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.Module)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName="widgetName"> + <MemberSignature Language="C#" Value="public static string widgetName { get; }" /> + <MemberSignature Language="ILAsm" Value=".property string widgetName" /> + <MemberSignature Language="F#" Value="Widgets.WidgetsModule.widgetName : string" Usage="Widgets.WidgetsModule.widgetName" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Attributes> + <Attribute> + <AttributeName>get: System.Diagnostics.DebuggerNonUserCode</AttributeName> + </Attribute> + </Attributes> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/index.xml b/mdoc/Test/en.expected-fsharp/index.xml new file mode 100644 index 00000000..d0945053 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/index.xml @@ -0,0 +1,286 @@ +<Overview> + <Assemblies> + <Assembly Name="mdoc.Test.FSharp" Version="1.0.0.0"> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.FSharpInterfaceDataVersion(2, 0, 0)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute+DebuggingModes.None)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyCompany("EPAM Systems")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyConfiguration("")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyCopyright("Copyright © EPAM Systems 2017")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyCulture("")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyDescription("")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyFileVersion("1.0.0.0")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyProduct("mdoc.Test.FSharp")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyTitle("mdoc.Test.FSharp")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyTrademark("")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Reflection.AssemblyVersion("1.0.0.0")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Runtime.InteropServices.ComVisible(false)</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Runtime.InteropServices.Guid("979f9f80-12fe-4236-9e93-6d554ab13701")</AttributeName> + </Attribute> + <Attribute> + <AttributeName>System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.6.1", FrameworkDisplayName=".NET Framework 4.6.1")</AttributeName> + </Attribute> + </Attributes> + </Assembly> + </Assemblies> + <Remarks>To be added.</Remarks> + <Copyright>To be added.</Copyright> + <Types> + <Namespace Name=""> + <Type Name="AbstractClasses" Kind="Class" /> + <Type Name="AbstractClasses+Circle" Kind="Class" /> + <Type Name="AbstractClasses+Shape2D" Kind="Class" /> + <Type Name="AbstractClasses+Square" Kind="Class" /> + <Type Name="Accessibility" Kind="Class" /> + <Type Name="AccessibilityTest" Kind="Class" /> + <Type Name="AlternativesToInheritance" Kind="Class" /> + <Type Name="Animals" Kind="Class" /> + <Type Name="Animals+Animal" Kind="Class" /> + <Type Name="Animals+Dog" Kind="Class" /> + <Type Name="Attributes" Kind="Class" /> + <Type Name="Attributes+CompanyAttribute" Kind="Class" /> + <Type Name="Attributes+OwnerAttribute" Kind="Class" /> + <Type Name="Attributes+SomeType1" Kind="Class" /> + <Type Name="Attributes+TypeWithFlagAttribute" Kind="Class" /> + <Type Name="ClassMembers" Kind="Class" /> + <Type Name="ClassMembers+PointWithCounter" Kind="Class" /> + <Type Name="Collections" Kind="Class" /> + <Type Name="Constraints" Kind="Class" /> + <Type Name="Constraints+Class1`1" DisplayName="Constraints+Class1<T>" Kind="Class" /> + <Type Name="Constraints+Class10`1" DisplayName="Constraints+Class10<T>" Kind="Class" /> + <Type Name="Constraints+Class11`1" DisplayName="Constraints+Class11<T>" Kind="Class" /> + <Type Name="Constraints+Class12`1" DisplayName="Constraints+Class12<T>" Kind="Class" /> + <Type Name="Constraints+Class13`1" DisplayName="Constraints+Class13<T>" Kind="Class" /> + <Type Name="Constraints+Class14`2" DisplayName="Constraints+Class14<T,U>" Kind="Class" /> + <Type Name="Constraints+Class15" Kind="Class" /> + <Type Name="Constraints+Class16" Kind="Class" /> + <Type Name="Constraints+Class17" Kind="Class" /> + <Type Name="Constraints+Class18" Kind="Class" /> + <Type Name="Constraints+Class2_1`1" DisplayName="Constraints+Class2_1<T>" Kind="Class" /> + <Type Name="Constraints+Class2`1" DisplayName="Constraints+Class2<T>" Kind="Class" /> + <Type Name="Constraints+Class3`1" DisplayName="Constraints+Class3<T>" Kind="Class" /> + <Type Name="Constraints+Class4`1" DisplayName="Constraints+Class4<T>" Kind="Class" /> + <Type Name="Constraints+Class5`1" DisplayName="Constraints+Class5<T>" Kind="Class" /> + <Type Name="Constraints+Class6`1" DisplayName="Constraints+Class6<T>" Kind="Class" /> + <Type Name="Constraints+Class7`1" DisplayName="Constraints+Class7<T>" Kind="Class" /> + <Type Name="Constraints+Class8`1" DisplayName="Constraints+Class8<T>" Kind="Class" /> + <Type Name="Constraints+Class9`1" DisplayName="Constraints+Class9<T>" Kind="Class" /> + <Type Name="Constructors" Kind="Class" /> + <Type Name="Constructors+Account" Kind="Class" /> + <Type Name="Constructors+Account2" Kind="Class" /> + <Type Name="Constructors+BaseClass" Kind="Class" /> + <Type Name="Constructors+DerivedClass" Kind="Class" /> + <Type Name="Constructors+MyClass" Kind="Class" /> + <Type Name="Constructors+MyClass1" Kind="Class" /> + <Type Name="Constructors+MyClass2" Kind="Class" /> + <Type Name="Constructors+MyClass3" Kind="Class" /> + <Type Name="Constructors+MyClass3_1" Kind="Class" /> + <Type Name="Constructors+MyClass3_2" Kind="Class" /> + <Type Name="Constructors+MyClass3_3" Kind="Class" /> + <Type Name="Constructors+MyClass3_4" Kind="Class" /> + <Type Name="Constructors+MyClassBase2" Kind="Class" /> + <Type Name="Constructors+MyClassDerived2" Kind="Class" /> + <Type Name="Constructors+MyClassObjectParameters" Kind="Class" /> + <Type Name="Constructors+MyStruct" Kind="Structure" /> + <Type Name="Constructors+MyStruct2" Kind="Structure" /> + <Type Name="Constructors+MyStruct33" Kind="Structure" /> + <Type Name="Constructors+MyStruct44" Kind="Structure" /> + <Type Name="Constructors+MyStruct55" Kind="Structure" /> + <Type Name="Constructors+MyStruct66" Kind="Structure" /> + <Type Name="Constructors+MyStruct77" Kind="Structure" /> + <Type Name="Constructors+MyStruct88" Kind="Structure" /> + <Type Name="Constructors+MyType" Kind="Class" /> + <Type Name="Constructors+Person" Kind="Class" /> + <Type Name="Constructors+Pet" Kind="Class" /> + <Type Name="Constructors+PetData" Kind="Class" /> + <Type Name="Customers" Kind="Class" /> + <Type Name="Customers+ICustomer" Kind="Interface" /> + <Type Name="Delegates" Kind="Class" /> + <Type Name="Delegates+Delegate1" Kind="Delegate" /> + <Type Name="Delegates+Delegate10" Kind="Delegate" /> + <Type Name="Delegates+Delegate11" Kind="Delegate" /> + <Type Name="Delegates+Delegate12" Kind="Delegate" /> + <Type Name="Delegates+Delegate13" Kind="Delegate" /> + <Type Name="Delegates+Delegate2" Kind="Delegate" /> + <Type Name="Delegates+Delegate3" Kind="Delegate" /> + <Type Name="Delegates+Delegate4" Kind="Delegate" /> + <Type Name="Delegates+Delegate5" Kind="Delegate" /> + <Type Name="Delegates+Delegate6" Kind="Delegate" /> + <Type Name="Delegates+Delegate7" Kind="Delegate" /> + <Type Name="Delegates+Delegate8" Kind="Delegate" /> + <Type Name="Delegates+Delegate9" Kind="Delegate" /> + <Type Name="Delegates+Test1" Kind="Class" /> + <Type Name="DiscriminatedUnions" Kind="Class" /> + <Type Name="DiscriminatedUnions+ColorEnum" Kind="Enumeration" /> + <Type Name="DiscriminatedUnions+Shape" Kind="Class" /> + <Type Name="DiscriminatedUnions+Shape+Circle" Kind="Class" /> + <Type Name="DiscriminatedUnions+Shape+Prism" Kind="Class" /> + <Type Name="DiscriminatedUnions+Shape+Rectangle" Kind="Class" /> + <Type Name="DiscriminatedUnions+Shape+Tags" Kind="Class" /> + <Type Name="DiscriminatedUnions+SizeUnion" Kind="Class" /> + <Type Name="DiscriminatedUnions+SizeUnion+Tags" Kind="Class" /> + <Type Name="DoBindings" Kind="Class" /> + <Type Name="DoBindings+MyBindingType" Kind="Class" /> + <Type Name="Enumerations" Kind="Class" /> + <Type Name="Enumerations+Color" Kind="Enumeration" /> + <Type Name="Extensions" Kind="Class" /> + <Type Name="Extensions+MyModule1" Kind="Class" /> + <Type Name="Extensions+MyModule1+MyClass" Kind="Class" /> + <Type Name="Extensions+MyModule2" Kind="Class" /> + <Type Name="FlexibleTypes" Kind="Class" /> + <Type Name="Functions" Kind="Class" /> + <Type Name="Functions+TestFunction" Kind="Class" /> + <Type Name="Generics" Kind="Class" /> + <Type Name="Generics+Map2`2" DisplayName="Generics+Map2<Key,Value>" Kind="Class" /> + <Type Name="IndexedProperties" Kind="Class" /> + <Type Name="IndexedProperties+NumberStrings" Kind="Class" /> + <Type Name="Inheritance" Kind="Class" /> + <Type Name="Inheritance+BaseClass" Kind="Class" /> + <Type Name="Inheritance+DerivedClass" Kind="Class" /> + <Type Name="Inheritance+MyClassBase1" Kind="Class" /> + <Type Name="Inheritance+MyClassBase2" Kind="Class" /> + <Type Name="Inheritance+MyClassDerived1" Kind="Class" /> + <Type Name="Inheritance+MyClassDerived2" Kind="Class" /> + <Type Name="InlineFunctions" Kind="Class" /> + <Type Name="InlineFunctions+WrapInt32" Kind="Class" /> + <Type Name="Interfaces" Kind="Class" /> + <Type Name="Interfaces+Interface0" Kind="Interface" /> + <Type Name="Interfaces+Interface1" Kind="Interface" /> + <Type Name="Interfaces+Interface2" Kind="Interface" /> + <Type Name="Interfaces+Interface3" Kind="Interface" /> + <Type Name="Interfaces+IPrintable" Kind="Interface" /> + <Type Name="Interfaces+MyClass" Kind="Class" /> + <Type Name="Interfaces+SomeClass1" Kind="Class" /> + <Type Name="Interfaces+SomeClass2" Kind="Class" /> + <Type Name="Literals" Kind="Class" /> + <Type Name="Methods" Kind="Class" /> + <Type Name="Methods+Circle" Kind="Class" /> + <Type Name="Methods+Ellipse" Kind="Class" /> + <Type Name="Methods+RectangleXY" Kind="Class" /> + <Type Name="Methods+SomeType" Kind="Class" /> + <Type Name="NestedModules" Kind="Class" /> + <Type Name="NestedModules+X" Kind="Class" /> + <Type Name="NestedModules+Y" Kind="Class" /> + <Type Name="NestedModules+Y+Z" Kind="Class" /> + <Type Name="NestedTypes" Kind="Class" /> + <Type Name="OperatorGlobalLevel" Kind="Class" /> + <Type Name="OperatorsOverloading" Kind="Class" /> + <Type Name="OperatorsOverloading+Vector" Kind="Class" /> + <Type Name="Properties" Kind="Class" /> + <Type Name="Properties+MyAutoPropertyClass" Kind="Class" /> + <Type Name="Properties+MyPropertiesType" Kind="Class" /> + <Type Name="Properties+MyPropertyClass2" Kind="Class" /> + <Type Name="Records" Kind="Class" /> + <Type Name="Records+Car" Kind="Class" /> + <Type Name="Records+MyRecord" Kind="Class" /> + <Type Name="ReferenceCells" Kind="Class" /> + <Type Name="Structures" Kind="Class" /> + <Type Name="Structures+Point2D" Kind="Structure" /> + <Type Name="Structures+Point3D" Kind="Structure" /> + <Type Name="Structures+StructureType" Kind="Structure" /> + <Type Name="Structures+StructureType2" Kind="Structure" /> + <Type Name="TypeExtensions" Kind="Class" /> + <Type Name="TypeExtensions+ExtraCSharpStyleExtensionMethodsInFSharp" Kind="Class" /> + <Type Name="TypeExtensions+TypeExtensions1" Kind="Class" /> + <Type Name="TypeExtensions+TypeExtensions1+MyClass" Kind="Class" /> + <Type Name="TypeExtensions+TypeExtensions2" Kind="Class" /> + <Type Name="UnitsOfMeasure" Kind="Class" /> + <Type Name="UnitsOfMeasure+bar" Kind="Class" /> + <Type Name="UnitsOfMeasure+cm" Kind="Class" /> + <Type Name="UnitsOfMeasure+ft" Kind="Class" /> + <Type Name="UnitsOfMeasure+g" Kind="Class" /> + <Type Name="UnitsOfMeasure+inch" Kind="Class" /> + <Type Name="UnitsOfMeasure+kg" Kind="Class" /> + <Type Name="UnitsOfMeasure+L" Kind="Class" /> + <Type Name="UnitsOfMeasure+lb" Kind="Class" /> + <Type Name="UnitsOfMeasure+m" Kind="Class" /> + <Type Name="UnitsOfMeasure+s" Kind="Class" /> + <Type Name="UnitsOfMeasure+vector3D" Kind="Class" /> + </Namespace> + <Namespace Name="mdoc.Test.FSharp"> + <Type Name="Class1" Kind="Class" /> + <Type Name="ClassPipes" Kind="Class" /> + </Namespace> + <Namespace Name="PatternMatching"> + <Type Name="PatternMatchingExamples" Kind="Class" /> + <Type Name="PatternMatchingExamples+Color" Kind="Enumeration" /> + <Type Name="PatternMatchingExamples+MyRecord" Kind="Class" /> + <Type Name="PatternMatchingExamples+PersonName" Kind="Class" /> + <Type Name="PatternMatchingExamples+PersonName+FirstLast" Kind="Class" /> + <Type Name="PatternMatchingExamples+PersonName+FirstOnly" Kind="Class" /> + <Type Name="PatternMatchingExamples+PersonName+LastOnly" Kind="Class" /> + <Type Name="PatternMatchingExamples+PersonName+Tags" Kind="Class" /> + <Type Name="PatternMatchingExamples+Shape" Kind="Class" /> + <Type Name="PatternMatchingExamples+Shape+Circle" Kind="Class" /> + <Type Name="PatternMatchingExamples+Shape+Rectangle" Kind="Class" /> + <Type Name="PatternMatchingExamples+Shape+Tags" Kind="Class" /> + </Namespace> + <Namespace Name="SomeNamespace"> + <Type Name="SomeModule" Kind="Class" /> + <Type Name="SomeModule+IVector" Kind="Interface" /> + <Type Name="SomeModule+Vector" Kind="Class" /> + <Type Name="SomeModule+Vector'''" Kind="Class" /> + <Type Name="SomeModule+Vector2" Kind="Class" /> + </Namespace> + <Namespace Name="Widgets"> + <Type Name="MyWidget1" Kind="Class" /> + <Type Name="WidgetsModule" Kind="Class" /> + </Namespace> + </Types> + <Title>mdoc.Test.FSharp</Title> + <ExtensionMethods> + <ExtensionMethod> + <Targets> + <Target Type="T:System.Collections.Generic.IEnumerable`1" /> + </Targets> + <Member MemberName="Sum<T>"> + <MemberSignature Language="C#" Value="public static T Sum<T> (this System.Collections.Generic.IEnumerable<T> xs);" /> + <MemberSignature Language="ILAsm" Value=".method public static !!T Sum<T>(class System.Collections.Generic.IEnumerable`1<!!T> xs) cil managed" /> + <MemberSignature Language="F#" Value="static member Sum : seq<'T> -> 'T" Usage="TypeExtensions.ExtraCSharpStyleExtensionMethodsInFSharp.Sum xs" /> + <MemberType>ExtensionMethod</MemberType> + <ReturnValue> + <ReturnType>T</ReturnType> + </ReturnValue> + <TypeParameters> + <TypeParameter Name="T" /> + </TypeParameters> + <Parameters> + <Parameter Name="xs" Type="System.Collections.Generic.IEnumerable<T>" RefType="this" /> + </Parameters> + <Docs> + <typeparam name="T">To be added.</typeparam> + <param name="xs">To be added.</param> + <summary>To be added.</summary> + </Docs> + <Link Type="TypeExtensions.ExtraCSharpStyleExtensionMethodsInFSharp" Member="M:TypeExtensions.ExtraCSharpStyleExtensionMethodsInFSharp.Sum``1(System.Collections.Generic.IEnumerable{``0})" /> + </Member> + </ExtensionMethod> + </ExtensionMethods> +</Overview> diff --git a/mdoc/Test/en.expected-fsharp/mdoc.Test.FSharp/Class1.xml b/mdoc/Test/en.expected-fsharp/mdoc.Test.FSharp/Class1.xml new file mode 100644 index 00000000..faa8bc1f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/mdoc.Test.FSharp/Class1.xml @@ -0,0 +1,71 @@ +<Type Name="Class1" FullName="mdoc.Test.FSharp.Class1"> + <TypeSignature Language="C#" Value="public class Class1" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi serializable Class1 extends System.Object" /> + <TypeSignature Language="F#" Value="type Class1 = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public Class1 ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="T"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.Unit T { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.Unit T" /> + <MemberSignature Language="F#" Value="member this.T : unit" Usage="mdoc.Test.FSharp.Class1.T" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.Unit</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="X"> + <MemberSignature Language="C#" Value="public string X { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance string X" /> + <MemberSignature Language="F#" Value="member this.X : string" Usage="mdoc.Test.FSharp.Class1.X" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.String</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/mdoc.Test.FSharp/ClassPipes.xml b/mdoc/Test/en.expected-fsharp/mdoc.Test.FSharp/ClassPipes.xml new file mode 100644 index 00000000..8c5fba4f --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/mdoc.Test.FSharp/ClassPipes.xml @@ -0,0 +1,139 @@ +<Type Name="ClassPipes" FullName="mdoc.Test.FSharp.ClassPipes"> + <TypeSignature Language="C#" Value="public class ClassPipes" /> + <TypeSignature Language="ILAsm" Value=".class public auto ansi serializable ClassPipes extends System.Object" /> + <TypeSignature Language="F#" Value="type ClassPipes = class" /> + <AssemblyInfo> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Base> + <BaseTypeName>System.Object</BaseTypeName> + </Base> + <Interfaces /> + <Attributes> + <Attribute> + <AttributeName>Microsoft.FSharp.Core.CompilationMapping(Microsoft.FSharp.Core.SourceConstructFlags.ObjectType)</AttributeName> + </Attribute> + </Attributes> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + <Members> + <Member MemberName=".ctor"> + <MemberSignature Language="C#" Value="public ClassPipes ();" /> + <MemberSignature Language="ILAsm" Value=".method public specialname rtspecialname instance void .ctor() cil managed" /> + <MemberType>Constructor</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <Parameters /> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="bigPipeVol1"> + <MemberSignature Language="C#" Value="public double bigPipeVol1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 bigPipeVol1" /> + <MemberSignature Language="F#" Value="member this.bigPipeVol1 : double" Usage="mdoc.Test.FSharp.ClassPipes.bigPipeVol1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="bigPipeVol2"> + <MemberSignature Language="C#" Value="public double bigPipeVol2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 bigPipeVol2" /> + <MemberSignature Language="F#" Value="member this.bigPipeVol2 : double" Usage="mdoc.Test.FSharp.ClassPipes.bigPipeVol2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ff"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Quotations.FSharpVar ff { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Quotations.FSharpVar ff" /> + <MemberSignature Language="F#" Value="member this.ff : Var" Usage="mdoc.Test.FSharp.ClassPipes.ff" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Quotations.FSharpVar</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="ff3"> + <MemberSignature Language="C#" Value="public Microsoft.FSharp.Core.FSharpFunc<object[],Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<object[],Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.FSharpFunc<int,Microsoft.FSharp.Core.Unit>>>>> ff3 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.FSharp.Core.FSharpFunc`2<object[], class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<object[], class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.FSharpFunc`2<int32, class Microsoft.FSharp.Core.Unit>>>>> ff3" /> + <MemberSignature Language="F#" Value="member this.ff3 : obj[] -> int -> obj[] -> int -> int -> unit" Usage="mdoc.Test.FSharp.ClassPipes.ff3" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>Microsoft.FSharp.Core.FSharpFunc<System.Object[],Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Object[],Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.FSharpFunc<System.Int32,Microsoft.FSharp.Core.Unit>>>>></ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="smallPipeVol1"> + <MemberSignature Language="C#" Value="public double smallPipeVol1 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 smallPipeVol1" /> + <MemberSignature Language="F#" Value="member this.smallPipeVol1 : double" Usage="mdoc.Test.FSharp.ClassPipes.smallPipeVol1" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + <Member MemberName="smallPipeVol2"> + <MemberSignature Language="C#" Value="public double smallPipeVol2 { get; }" /> + <MemberSignature Language="ILAsm" Value=".property instance float64 smallPipeVol2" /> + <MemberSignature Language="F#" Value="member this.smallPipeVol2 : double" Usage="mdoc.Test.FSharp.ClassPipes.smallPipeVol2" /> + <MemberType>Property</MemberType> + <AssemblyInfo> + <AssemblyVersion>1.0.0.0</AssemblyVersion> + </AssemblyInfo> + <ReturnValue> + <ReturnType>System.Double</ReturnType> + </ReturnValue> + <Docs> + <summary>To be added.</summary> + <value>To be added.</value> + <remarks>To be added.</remarks> + </Docs> + </Member> + </Members> +</Type> diff --git a/mdoc/Test/en.expected-fsharp/ns-.xml b/mdoc/Test/en.expected-fsharp/ns-.xml new file mode 100644 index 00000000..36dfeb30 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ns-.xml @@ -0,0 +1,6 @@ +<Namespace Name=""> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> +</Namespace> diff --git a/mdoc/Test/en.expected-fsharp/ns-PatternMatching.xml b/mdoc/Test/en.expected-fsharp/ns-PatternMatching.xml new file mode 100644 index 00000000..43565bea --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ns-PatternMatching.xml @@ -0,0 +1,6 @@ +<Namespace Name="PatternMatching"> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> +</Namespace> diff --git a/mdoc/Test/en.expected-fsharp/ns-SomeNamespace.xml b/mdoc/Test/en.expected-fsharp/ns-SomeNamespace.xml new file mode 100644 index 00000000..46f18f79 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ns-SomeNamespace.xml @@ -0,0 +1,6 @@ +<Namespace Name="SomeNamespace"> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> +</Namespace> diff --git a/mdoc/Test/en.expected-fsharp/ns-Widgets.xml b/mdoc/Test/en.expected-fsharp/ns-Widgets.xml new file mode 100644 index 00000000..d67f95f7 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ns-Widgets.xml @@ -0,0 +1,6 @@ +<Namespace Name="Widgets"> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> +</Namespace> diff --git a/mdoc/Test/en.expected-fsharp/ns-mdoc.Test.FSharp.xml b/mdoc/Test/en.expected-fsharp/ns-mdoc.Test.FSharp.xml new file mode 100644 index 00000000..bd12c205 --- /dev/null +++ b/mdoc/Test/en.expected-fsharp/ns-mdoc.Test.FSharp.xml @@ -0,0 +1,6 @@ +<Namespace Name="mdoc.Test.FSharp"> + <Docs> + <summary>To be added.</summary> + <remarks>To be added.</remarks> + </Docs> +</Namespace> diff --git a/mdoc/mdoc.Test/BasicFormatterTests.cs b/mdoc/mdoc.Test/BasicFormatterTests.cs new file mode 100644 index 00000000..4bbefe15 --- /dev/null +++ b/mdoc/mdoc.Test/BasicFormatterTests.cs @@ -0,0 +1,150 @@ +using System; +using System.Linq; +using Mono.Cecil; +using Mono.Documentation.Updater; +using NUnit.Framework; + +namespace mdoc.Test +{ + public abstract class BasicFormatterTests<T> where T : MemberFormatter + { + protected abstract T formatter { get; } + + protected MethodDefinition GetMethod(Type type, Func<MethodDefinition, bool> query) + { + return GetMethod(GetType(type), query); + } + + protected MethodDefinition GetMethod(TypeDefinition testclass, Func<MethodDefinition, bool> query) + { + var methods = testclass.Methods; + var member = methods.FirstOrDefault(query).Resolve(); + if (member == null) + throw new Exception("Did not find the member in the test class"); + return member; + } + + protected MethodDefinition GetProperty(TypeDefinition testclass, Func<MethodDefinition, bool> query) + { + var methods = testclass.Methods; + var member = methods.FirstOrDefault(query).Resolve(); + if (member == null) + throw new Exception("Did not find the member in the test class"); + return member; + } + + protected TypeDefinition GetType(string filepath, string classname) + { + var module = ModuleDefinition.ReadModule(filepath); + var types = module.GetTypes(); + var testclass = types + .SingleOrDefault(t => t.FullName == classname); + if (testclass == null) + { + throw new Exception($"Test was unable to find type {classname}"); + } + return testclass.Resolve(); + } + + protected virtual TypeDefinition GetType(Type type) + { + var moduleName = type.Module.FullyQualifiedName; + return GetType(moduleName, type.FullName); + } + + protected MemberReference GetProperty(TypeDefinition type, string memberName) + { + var property = type.Properties.SingleOrDefault(i => i.Name == memberName); + if (property == null) + throw new Exception($"Can't find property {memberName}"); + return property; + } + + protected MemberReference GetField(TypeDefinition type, string eventName) + { + var property = type.Fields.SingleOrDefault(i => i.Name == eventName); + if (property == null) + throw new Exception($"Can't find field {eventName}"); + return property; + } + + protected MemberReference GetEvent(TypeDefinition type, string eventName) + { + var property = type.Events.SingleOrDefault(i => i.Name == eventName); + if (property == null) + throw new Exception($"Can't find field {eventName}"); + return property; + } + + protected void TestTypeSignature(Type type, string expected) + { + expected = FormatEndings(expected); + var signature = GetTypeSignature(type); + Assert.AreEqual(expected, signature); + } + + private string GetTypeSignature(Type type) + { + var tref = GetType(type); + var signature = formatter.GetDeclaration(tref); + return signature; + } + + protected void TestMethodSignature(Type type, string expected, string memberName) + { + var signature = GetMethodSignature(type, memberName); + Assert.AreEqual(FormatEndings(expected), signature); + } + + private string GetMethodSignature(Type type, string memberName) + { + var tref = GetType(type); + var method = GetMethod(tref, i => i.Name == memberName); + var signature = formatter.GetDeclaration(method); + return signature; + } + + protected void TestPropertySignature(Type type, string expected, string memberName) + { + var signature = GetPropertySignature(type, memberName); + Assert.AreEqual(expected, signature); + } + + private string GetPropertySignature(Type type, string memberName) + { + var tref = GetType(type); + return formatter.GetDeclaration(GetProperty(tref, memberName)); + } + + protected void TestEventSignature(Type type, string expected, string memberName) + { + var signature = GetEventSignature(type, memberName); + Assert.AreEqual(expected, signature); + } + + private string GetEventSignature(Type type, string memberName) + { + var tref = GetType(type); + return formatter.GetDeclaration(GetEvent(tref, memberName)); + } + + protected void TestFieldSignature(Type type, string expected, string memberName) + { + var usage = GetFieldUsage(type, memberName); + Assert.AreEqual(expected, usage); + } + + private string GetFieldUsage(Type type, string memberName) + { + var tref = GetType(type); + var field = GetField(tref, memberName); + var signature = formatter.GetDeclaration(field); + return signature; + } + + protected static string FormatEndings(string s) + { + return s?.Replace("\r\n", MemberFormatter.GetLineEnding()); + } + } +}
\ No newline at end of file diff --git a/mdoc/mdoc.Test/FSharp/BasicFSharpFormatterTests.cs b/mdoc/mdoc.Test/FSharp/BasicFSharpFormatterTests.cs new file mode 100644 index 00000000..12e40320 --- /dev/null +++ b/mdoc/mdoc.Test/FSharp/BasicFSharpFormatterTests.cs @@ -0,0 +1,18 @@ +using Mono.Cecil; +using Mono.Documentation.Updater; +using System; + +namespace mdoc.Test +{ + public abstract class BasicFSharpFormatterTests<T> : BasicFormatterTests<T> where T : MemberFormatter + { + protected override TypeDefinition GetType(Type type) + { + var moduleName = type.Module.FullyQualifiedName; + + // Can't use base.GetType, F# assemblies use '/' instead of '+' + var tref = GetType(moduleName, type.FullName.Replace("+", "/")); + return tref; + } + } +}
\ No newline at end of file diff --git a/mdoc/mdoc.Test/FSharp/FSharpFormatterTests.cs b/mdoc/mdoc.Test/FSharp/FSharpFormatterTests.cs new file mode 100644 index 00000000..fb75868d --- /dev/null +++ b/mdoc/mdoc.Test/FSharp/FSharpFormatterTests.cs @@ -0,0 +1,928 @@ +using System; +using mdoc.Test.FSharp; +using Microsoft.FSharp.Collections; +using Microsoft.FSharp.Control; +using Microsoft.FSharp.Core; +using Mono.Documentation.Updater; +using NUnit.Framework; + +namespace mdoc.Test +{ + [TestFixture] + [Category("FSharp")] + public class FSharpFormatterTests : BasicFSharpFormatterTests<FSharpMemberFormatter> + { + private static readonly FSharpMemberFormatter fSharpMemberFormatter = new FSharpMemberFormatter(); + protected override FSharpMemberFormatter formatter => fSharpMemberFormatter; + + #region Types + [Test] + [Category("Types")] + public void TypeSignature_Class1() => + TestTypeSignature(typeof(Class1), @"type Class1 = class"); + + + [Test] + [Category("Types")] + public void TypeSignature_Struct() => + TestTypeSignature(typeof(Constructors.MyStruct), + "type Constructors.MyStruct = struct"); + + [Test] + [Category("Types")] + public void TypeSignature_Record() => + TestTypeSignature(typeof(Constructors.PetData), +@"type Constructors.PetData = {}"); + + [Test] + [Category("Types")] + public void TypeSignature_Record2() => + TestTypeSignature(typeof(Records.Car), + "type Records.Car = {}"); + + [Test] + [Category("Types")] + [Category("Modules")] + public void TypeSignature_Module() => + TestTypeSignature(typeof(Records), "module Records"); + + [Test] + [Category("Types")] + [Category("Modules")] + public void TypeSignature_TopLevelModule() => + TestTypeSignature(typeof(NestedModules), "module NestedModules"); + + [Test] + [Category("Types")] + [Category("Modules")] + public void TypeSignature_NestingModule() => + TestTypeSignature(typeof(NestedModules.Y), +@"module NestedModules.Y"); + + [Test] + [Category("Types")] + [Category("Modules")] + public void TypeSignature_NestedModule() => + TestTypeSignature(typeof(NestedModules.Y.Z), +@"module NestedModules.Y.Z"); + + [Test] + [Category("Types")] + public void TypeSignature_Attribute() => + TestTypeSignature(typeof(Attributes.TypeWithFlagAttribute), +@"type Attributes.TypeWithFlagAttribute = class"); + + [Test] + [Category("Types")] + public void TypeSignature_Inheritance() => + TestTypeSignature(typeof(Attributes.OwnerAttribute), +@"type Attributes.OwnerAttribute = class + inherit Attribute"); + + [Test] + [Category("Types")] + [Category("Interfaces")] + public void TypeSignature_InterfaceImplementation() => + TestTypeSignature(typeof(Interfaces.SomeClass1), +@"type Interfaces.SomeClass1 = class + interface Interfaces.IPrintable"); + + [Test] + [Category("Types")] + [Category("Interfaces")] + public void TypeSignature_Interface() => + TestTypeSignature(typeof(Interfaces.Interface0), +@"type Interfaces.Interface0 = interface"); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_0() => + TestTypeSignature(typeof(DiscriminatedUnions.Shape), + "type DiscriminatedUnions.Shape = "); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_1() => + TestTypeSignature(typeof(DiscriminatedUnions.Shape.Tags), + null); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_2() => + TestTypeSignature(typeof(DiscriminatedUnions.Shape.Circle), + "DiscriminatedUnions.Shape.Circle : double -> DiscriminatedUnions.Shape"); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_3() => + TestTypeSignature(typeof(DiscriminatedUnions.Shape.Rectangle), + "DiscriminatedUnions.Shape.Rectangle : double * double -> DiscriminatedUnions.Shape"); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_4() => + TestTypeSignature(typeof(DiscriminatedUnions.SizeUnion), + "type DiscriminatedUnions.SizeUnion = "); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_5() => + TestPropertySignature( + typeof(DiscriminatedUnions.SizeUnion), + "member this.Small : DiscriminatedUnions.SizeUnion", + nameof(DiscriminatedUnions.SizeUnion.Small)); + + [Test] + [Category("Types")] + [Category("DiscriminatedUnions")] + public void TypeSignature_Union_6() => + TestPropertySignature( + typeof(DiscriminatedUnions.SizeUnion), + null, + "IsSmall"); + + [Test] + [Category("Types")] + [Category("Enums")] + public void TypeSignature_Enum_0() => + TestTypeSignature(typeof(DiscriminatedUnions.ColorEnum), + "type DiscriminatedUnions.ColorEnum = "); + + [Test] + [Category("Types")] + [Category("Enums")] + public void TypeSignature_Enum_1() => + TestFieldSignature(typeof(DiscriminatedUnions.ColorEnum), + "Red = 5", + nameof(DiscriminatedUnions.ColorEnum.Red)); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_0() => + TestTypeSignature(typeof(Delegates.Delegate1), + @"type Delegates.Delegate1 = delegate of (int * int) -> int"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_1() => + TestTypeSignature(typeof(Delegates.Delegate2), + @"type Delegates.Delegate2 = delegate of int * int -> int"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_2() => + TestTypeSignature(typeof(Delegates.Delegate3), + @"type Delegates.Delegate3 = delegate of int * char -> string"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_3() => + TestTypeSignature(typeof(Delegates.Delegate4), + @"type Delegates.Delegate4 = delegate of int -> (int -> char)"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_4() => + TestTypeSignature(typeof(Delegates.Delegate5), + @"type Delegates.Delegate5 = delegate of int -> (int -> char -> string)"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_5() => + TestTypeSignature(typeof(Delegates.Delegate6), + @"type Delegates.Delegate6 = delegate of (int -> double) -> char"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_6() => + TestTypeSignature(typeof(Delegates.Delegate7), + @"type Delegates.Delegate7 = delegate of (int -> char -> string) -> double"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_7() => + TestTypeSignature(typeof(Delegates.Delegate8), + @"type Delegates.Delegate8 = delegate of int -> char"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_8() => + TestTypeSignature(typeof(Delegates.Delegate9), + @"type Delegates.Delegate9 = delegate of (int * int) -> char"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_9() => + TestTypeSignature(typeof(Delegates.Delegate10), + @"type Delegates.Delegate10 = delegate of int * int -> char"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_10() => + TestTypeSignature(typeof(Delegates.Delegate11), + @"type Delegates.Delegate11 = delegate of char -> unit"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_11() => + TestTypeSignature(typeof(Delegates.Delegate12), + @"type Delegates.Delegate12 = delegate of unit -> char"); + + [Test] + [Category("Types")] + [Category("Delegates")] + public void TypeSignature_Delegate_12() => + TestTypeSignature(typeof(Delegates.Delegate13), + @"type Delegates.Delegate13 = delegate of (int -> char -> string -> decimal) -> double"); + + #endregion + + #region Functions + [Test] + [Category("Functions")] + public void FunctionsSignature_1() => + TestMethodSignature(typeof(Functions), "Functions.function1 : int -> int", nameof(Functions.function1)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_2() => + TestMethodSignature(typeof(Functions), "Functions.function2 : int -> int", nameof(Functions.function2)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_3() => + TestMethodSignature(typeof(Functions), "Functions.function3 : int -> int", nameof(Functions.function3)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_4() => + TestMethodSignature(typeof(Functions), "Functions.function4 : int -> int -> int", nameof(Functions.function4)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_5() => + TestMethodSignature(typeof(Functions), "Functions.function5 : int * int -> int", nameof(Functions.function5)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_6() => + TestMethodSignature(typeof(Functions), "Functions.function6 : 'a * 'b -> unit", nameof(Functions.function6)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_7() => + TestMethodSignature(typeof(Functions), "Functions.function7 : 'a -> 'b * 'c -> unit", nameof(Functions.function7)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_8() => + TestMethodSignature(typeof(Functions), "Functions.function8 : 'a -> 'b -> 'c -> unit", nameof(Functions.function8)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_9() => + TestMethodSignature(typeof(Functions), "Functions.function9 : 'a * 'b -> 'c * 'd -> unit", nameof(Functions.function9)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_10() => + TestMethodSignature(typeof(Functions), "Functions.function10 : obj * obj -> obj * obj -> unit", nameof(Functions.function10)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_11() => + TestMethodSignature(typeof(Functions), "Functions.function11 : obj * obj * obj -> obj * obj -> unit", nameof(Functions.function11)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_12() => + TestMethodSignature(typeof(Functions), "Functions.function12 : obj -> obj * obj * obj * obj * obj -> unit", nameof(Functions.function12)); + + [Test] + [Category("Functions")] + [Category("FSharpCore")] + [Ignore("No ^U in IL code")] + public void FunctionsSignature_13() => + TestMethodSignature(typeof(ArrayModule), + "Array.averageBy : ('T -> ^U) -> 'T [] -> ^U", + "AverageBy"); + + [Test] + [Category("Functions")] + [Category("FSharpCore")] + public void FunctionsSignature_14() => + TestMethodSignature(typeof(Collections), + "Collections.f : Map<int, int> -> int", + nameof(Collections.f)); + + [Test] + [Category("Functions")] + [Category("FSharpCore")] + public void FunctionsSignature_15() => + TestMethodSignature(typeof(Collections), + "Collections.f2 : seq<int> -> int", + nameof(Collections.f2)); + + [Test] + [Category("Functions")] + public void FunctionsSignature_16() => + TestMethodSignature(typeof(PatternMatching.PatternMatchingExamples), + "PatternMatchingExamples.countValues : List<'a> -> 'a -> int", + "countValues"); + + [Test] + [Category("Functions")] + public void FunctionsSignature_17() => + TestMethodSignature(typeof(FlexibleTypes), + "FlexibleTypes.iterate1 : (unit -> seq<int>) -> unit", + nameof(FlexibleTypes.iterate1)); + + [Test] + [Category("Functions")] + [Category("FlexibleTypes")] + public void FunctionsSignature_18() => + TestMethodSignature(typeof(FlexibleTypes), + "FlexibleTypes.iterate2 : (unit -> #seq<int>) -> unit", + nameof(FlexibleTypes.iterate2)); + #endregion + + #region Methods + [Test] + [Category("Methods")] + public void MethodSignature_1() => + TestMethodSignature(typeof(Methods.SomeType), + "member this.SomeMethod : int * int * int -> int", + nameof(Methods.SomeType.SomeMethod)); + + [Test] + [Category("Methods")] + public void MethodSignature_2() => + TestMethodSignature(typeof(Methods.SomeType), + "member this.SomeOtherMethod : int * int * int -> int", + nameof(Methods.SomeType.SomeOtherMethod)); + + [Test] + [Category("Methods")] + public void MethodSignature_3() => + TestMethodSignature(typeof(Collections), + "Collections.f : Map<int, int> -> int", + nameof(Collections.f)); + + [Test] + [Category("Methods")] + public void MethodSignature_4() => + TestMethodSignature(typeof(Collections), + "Collections.f2 : seq<int> -> int", + nameof(Collections.f2)); + + [Test] + [Category("Methods")] + public void MethodSignature_StaticMethod() => + TestMethodSignature(typeof(Methods.SomeType), + "static member SomeStaticMethod : int * int * int -> int", + nameof(Methods.SomeType.SomeStaticMethod)); + + [Test] + [Category("Methods")] + public void MethodSignature_StaticMethod_2() => + TestMethodSignature(typeof(Methods.SomeType), + "static member SomeOtherStaticMethod : int * int * int -> int", + nameof(Methods.SomeType.SomeOtherStaticMethod)); + + + [Test] + [Category("Methods")] + public void MethodSignature_StaticMethod_3() => + TestMethodSignature(typeof(Methods.SomeType), + "static member SomeOtherStaticMethod3 : int * int -> int -> int -> int", + nameof(Methods.SomeType.SomeOtherStaticMethod3)); + + + [Test] + [Category("Methods")] + public void MethodSignature_AbstractMethod() => + TestMethodSignature(typeof(AbstractClasses.Shape2D), + "abstract member Rotate2 : double -> unit", + nameof(AbstractClasses.Shape2D.Rotate2)); + + [Test] + [Category("Methods")] + public void MethodSignature_VirtualMethod() => + TestMethodSignature(typeof(AbstractClasses.Shape2D), +@"abstract member Rotate : double -> unit +override this.Rotate : double -> unit", + nameof(AbstractClasses.Shape2D.Rotate)); + + [Test] + [Category("Methods")] + public void MethodSignature_OverrideMethod() => + TestMethodSignature(typeof(AbstractClasses.Circle), + "override this.Rotate : double -> unit", + nameof(AbstractClasses.Circle.Rotate)); + + [Test] + [Category("Methods")] + public void MethodSignature_MethodWithOptionResult() => + TestMethodSignature(typeof(Methods.RectangleXY), + "static member intersection : Methods.RectangleXY * Methods.RectangleXY -> option<Methods.RectangleXY>", + nameof(Methods.RectangleXY.intersection)); + + [Test] + [Category("Methods")] + public void MethodSignature_MethodWithRefParameter() => + TestMethodSignature(typeof(Methods.SomeType), + "member this.TestRefParam : ref<int> -> int", + nameof(Methods.SomeType.TestRefParam)); + + #endregion + + #region Constructors + [Test] + [Category("Constructors")] + public void MethodSignature_Constructor_0() => + TestMethodSignature(typeof(Interfaces.SomeClass1), + "new Interfaces.SomeClass1 : int * double -> Interfaces.SomeClass1", + ".ctor"); + + [Test] + [Category("Constructors")] + public void MethodSignature_Constructor_1() => + TestMethodSignature(typeof(Constructors.MyClass), + "new Constructors.MyClass : int * int * int -> Constructors.MyClass", + ".ctor"); + + [Test] + [Category("Types")] + public void TypeSignature_ClassWithPrimaryConstructorWithObjArguments() => + TestMethodSignature(typeof(Constructors.MyClassObjectParameters), + "new Constructors.MyClassObjectParameters : string * obj * obj -> Constructors.MyClassObjectParameters", + ".ctor"); + #endregion + + #region Properties + [Test] + [Category("Properties")] + public void PropertySignature_0() => + TestPropertySignature(typeof(Methods.RectangleXY), + "member this.X1 : double", + nameof(Methods.RectangleXY.X1)); + + [Test] + [Category("Properties")] + public void PropertySignature_1() => + TestPropertySignature(typeof(Interfaces), + "Interfaces.x1 : Interfaces.SomeClass1", + nameof(Interfaces.x1)); + + + [Test] + [Category("Properties")] + public void PropertySignature_2() => + TestPropertySignature(typeof(Class1), + "member this.T : unit", + "T"); + + [Test] + [Category("Properties")] + public void PropertySignature_3() => + TestPropertySignature(typeof(Constructors.MyClass3_2), + "val a : int", + nameof(Constructors.MyClass3_2.a)); + + [Test] + [Category("Properties")] + public void PropertySignature_4() => + TestPropertySignature(typeof(Constructors.MyClass3_2), + "member this.b : int", + nameof(Constructors.MyClass3_2.b)); + + [Test] + [Category("Properties")] + public void PropertySignature_5() => + TestPropertySignature(typeof(Constructors.MyClass), + @"member this.X : int with get, set", + nameof(Constructors.MyClass.X)); + + [Test] + [Category("Properties")] + [Category("Records")] + public void PropertySignature_RecordTypeProperty_0() => + TestPropertySignature(typeof(Constructors.PetData), + "name : string", + nameof(Constructors.PetData.name)); + + [Test] + [Category("Properties")] + [Category("Records")] + public void PropertySignature_RecordTypeProperty_1() => + TestPropertySignature(typeof(Records.Car), + "mutable Odometer : int", + nameof(Records.Car.Odometer)); + + [Test] + [Category("Properties")] + [Category("Records")] + public void PropertySignature_RecordTypeProperty_2() => + TestPropertySignature(typeof(Records.Car), + "Make : string", + nameof(Records.Car.Make)); + + [Test] + [Category("Properties")] + public void PropertySignature_6() => + TestPropertySignature(typeof(Methods.SomeType), + "member this.SomeOtherMethod2 : int -> int * int -> int * int", + nameof(Methods.SomeType.SomeOtherMethod2)); + + [Test] + [Category("Properties")] + public void PropertySignature_7() => + TestPropertySignature(typeof(Methods.SomeType), + "member this.SomeOtherMethod3 : (int -> int) * int -> int * int", + nameof(Methods.SomeType.SomeOtherMethod3)); + #endregion + + #region Fields + [Test] + [Category("Fields")] + public void FieldSignature_0() => + TestFieldSignature(typeof(Constructors.MyClass3_3), + "val mutable b : int", + nameof(Constructors.MyClass3_3.b)); + #endregion + + #region Interfaces + [Test] + [Category("Properties")] + public void InterfaceSignature_0() => + TestPropertySignature(typeof(Interfaces), "Interfaces.x1 : Interfaces.SomeClass1", nameof(Interfaces.x1)); + + #endregion + + #region FSharp.Core + [Test] + [Category("Types")] + [Category("FSharpCore")] + public void TypeSignature_MailboxProcessor() => + TestTypeSignature(typeof(FSharpMailboxProcessor<>), +@"type MailboxProcessor<'Msg> = class + interface IDisposable"); + + [Test] + [Category("Constructors")] + [Category("FSharpCore")] + public void ConstructorSignature_MailboxProcessor() => + TestMethodSignature(typeof(FSharpMailboxProcessor<>), + "new MailboxProcessor<'Msg> : (MailboxProcessor<'Msg> -> Async<unit>) * option<CancellationToken> -> MailboxProcessor<'Msg>", + ".ctor"); + + [Test] + [Category("Methods")] + [Category("FSharpCore")] + public void MethodSignature_MailboxProcessor_0() => + TestMethodSignature(typeof(FSharpMailboxProcessor<>), + "member this.TryPostAndReply : (AsyncReplyChannel<'Reply> -> 'Msg) * option<int> -> option<'Reply>", + "TryPostAndReply"); + + [Test] + [Category("Methods")] + [Category("FSharpCore")] + public void MethodSignature_MailboxProcessor_1() => + TestMethodSignature(typeof(FSharpMailboxProcessor<>), + "member this.Scan : ('Msg -> option<Async<'T>>) * option<int> -> Async<'T>", + "Scan"); + + [Test] + [Category("Methods")] + [Category("FSharpCore")] + public void MethodSignature_MailboxProcessor_2() => + TestMethodSignature(typeof(FSharpMailboxProcessor<>), + "member this.TryScan : ('Msg -> option<Async<'T>>) * option<int> -> Async<option<'T>>", + "TryScan"); + + [Test] + [Category("Events")] + [Category("FSharpCore")] + public void MethodSignature_MailboxProcessor_3() => + TestEventSignature(typeof(FSharpMailboxProcessor<>), + "member this.Error : Handler<Exception> ", + "Error"); + + [Test] + [Category("Properties")] + [Category("FSharpCore")] + public void MethodSignature_MailboxProcessor_4() => + TestPropertySignature(typeof(FSharpMailboxProcessor<>), + "member this.DefaultTimeout : int with get, set", + "DefaultTimeout"); + + [Test] + [Category("Types")] + [Category("FSharpCore")] + public void TypeSignature_Map() => + TestTypeSignature(typeof(FSharpMap<,>), +@"type Map<'Key, 'Value> = class + interface IComparable + interface ICollection<KeyValuePair<'Key, 'Value>> + interface IDictionary<'Key, 'Value> + interface IEnumerable + interface seq<KeyValuePair<'Key, 'Value>>"); + + [Test] + [Category("Types")] + [Category("FSharpCore")] + public void PropertySignature_Map() => + TestPropertySignature(typeof(FSharpMap<,>), + "member this.Item('Key) : 'Value", + "Item"); + + [Test] + [Category("Methods")] + [Category("FSharpCore")] + public void TypeSignature_FSharpCore_3() => + TestMethodSignature(typeof(FSharpMailboxProcessor<>), + "member this.PostAndReply : (AsyncReplyChannel<'Reply> -> 'Msg) * option<int> -> 'Reply", + "PostAndReply"); + + [Test] + [Category("Methods")] + [Category("FlexibleTypes")] + [Category("FSharpCore")] + public void TypeSignature_FSharpCore_4() => + TestMethodSignature(typeof(ExtraTopLevelOperators), + "ExtraTopLevelOperators.array2D : seq<#seq<'T>> -> 'T[,]", + "CreateArray2D"); + #endregion + + #region Constraints + [Test] + [Category("Constraints")] + public void TestConstraints_1() => + TestTypeSignature(typeof(Constraints.Class1<>), + "type Constraints.Class1<'T (requires 'T :> Exception)> = class"); + + [Test] + [Category("Constraints")] + public void TestConstraints_2() => + TestTypeSignature(typeof(Constraints.Class2<>), + "type Constraints.Class2<'T (requires 'T :> IComparable)> = class"); + + [Test] + [Category("Constraints")] + public void TestConstraints_2_1() => + TestTypeSignature(typeof(Constraints.Class2_1<>), + "type Constraints.Class2_1<'T (requires 'T :> IComparable and 'T :> Exception)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_3() => + TestTypeSignature(typeof(Constraints.Class3<>), + "type Constraints.Class3<'T (requires 'T : null)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_4() => + TestTypeSignature(typeof(Constraints.Class4<>), + "type Constraints.Class4<'T (requires 'T : (static member staticMethod1 : unit -> 'T)) > = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_5() => + TestTypeSignature(typeof(Constraints.Class5<>), + "type Constraints.Class5<'T (requires 'T : (member Method1 : 'T -> int))> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_6() => + TestTypeSignature(typeof(Constraints.Class6<>), + "type Constraints.Class6<'T (requires 'T : (member Property1 : int))> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_7() => + TestTypeSignature(typeof(Constraints.Class7<>), + "type Constraints.Class7<'T (requires 'T : (new : unit -> 'T))> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_8() => + TestTypeSignature(typeof(Constraints.Class8<>), + "type Constraints.Class8<'T (requires 'T : not struct)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_9() => + TestTypeSignature(typeof(Constraints.Class9<>), + "type Constraints.Class9<'T (requires 'T : enum<uint32>)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_10() => + TestTypeSignature(typeof(Constraints.Class10<>), + "type Constraints.Class10<'T (requires 'T : comparison)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_11() => + TestTypeSignature(typeof(Constraints.Class11<>), + "type Constraints.Class11<'T (requires 'T : equality)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_12() => + TestTypeSignature(typeof(Constraints.Class12<>), + "type Constraints.Class12<'T (requires 'T : delegate<obj * System.EventArgs, unit>)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_13() => + TestTypeSignature(typeof(Constraints.Class13<>), + "type Constraints.Class13<'T (requires 'T : unmanaged)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_14() => + TestTypeSignature(typeof(Constraints.Class14<,>), + "type Constraints.Class14<'T,'U (requires 'T : equality and 'U : equality)> = class"); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_15() => + TestMethodSignature(typeof(Constraints.Class15), + "static member add : 'T * 'T -> 'T (requires 'T : static member ( + ))", + nameof(Constraints.Class15.add)); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_15_2() => + TestMethodSignature(typeof(Constraints.Class15), + "static member heterogenousAdd : 'T * 'U -> 'T (requires 'T : static member ( + ))", + nameof(Constraints.Class15.heterogenousAdd)); + + [Test] + [Category("Constraints")] + [Ignore("No constraint info in IL code")] + public void TestConstraints_16() => + TestMethodSignature(typeof(Constraints.Class16), + "static member add : 'T * 'T -> 'T (requires 'T : static member ( + ))", + nameof(Constraints.Class17.method)); + + [Test] + [Category("Constraints")] + public void TestConstraints_17() => + TestMethodSignature(typeof(Constraints.Class17), + "static member method : 'T * 'T -> unit (requires 'T : null)", + nameof(Constraints.Class17.method)); + + [Test] + [Category("Constraints")] + public void TestConstraints_18() => + TestMethodSignature(typeof(Constraints.Class18), +@"static member method : obj * obj -> unit", + nameof(Constraints.Class18.method)); + + [Test] + [Ignore("No constraint info in IL code")] + public void TestFSharpConstraints() + { + Constraints.Class1<Exception> c1 = new Constraints.Class1<Exception>(); + Constraints.Class2<IComparable> c2 = new Constraints.Class2<IComparable>(); + Constraints.Class2_1<ComparableException> c2_1 = new Constraints.Class2_1<ComparableException>(); + Constraints.Class3<EmptyClass> c3 = new Constraints.Class3<EmptyClass>(); + Constraints.Class4<EmptyClass> c4 = new Constraints.Class4<EmptyClass>(); + Constraints.Class5<EmptyClass> c5 = new Constraints.Class5<EmptyClass>(); + Constraints.Class6<EmptyClass> c6 = new Constraints.Class6<EmptyClass>(); + Constraints.Class7<EmptyClass> c7 = new Constraints.Class7<EmptyClass>(); + Constraints.Class8<EmptyClass> c8 = new Constraints.Class8<EmptyClass>(); + Constraints.Class9<EmptyClass> c9 = new Constraints.Class9<EmptyClass>(); + Constraints.Class10<EmptyClass> c10 = new Constraints.Class10<EmptyClass>(); + Constraints.Class11<EmptyClass> c11 = new Constraints.Class11<EmptyClass>(); + Constraints.Class12<EmptyClass> c12 = new Constraints.Class12<EmptyClass>(); + Constraints.Class13<EmptyClass> c13 = new Constraints.Class13<EmptyClass>(); + Constraints.Class14<EmptyClass, EmptyClass> c14 = new Constraints.Class14<EmptyClass, EmptyClass>(); + Constraints.Class15 c15 = new Constraints.Class15(); + + + Constraints.Class16.method(new EmptyClass(), new EmptyClass()); + Constraints.Class17.method(new EmptyClass(), new EmptyClass()); + Constraints.Class18.method(new EmptyClass(), new EmptyClass()); + + Constraints.Class15.add(new EmptyClass(), new EmptyClass()); + Constraints.Class15.heterogenousAdd(new EmptyClass(), new EmptyStruct()); + } + + private class ComparableException : Exception, IComparable + { + public int CompareTo(object obj) + { + return 0; + } + } + + private class EmptyClass + { + } + private struct EmptyStruct + { + } + + #endregion + + #region Operators + [Test] + [Category("Operators")] + public void Operators_0() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"static member ( * ) : OperatorsOverloading.Vector * double -> OperatorsOverloading.Vector", +"op_Multiply"); + // Well, there would be OperatorsOverloading.Vector -> double in MSDN, but there are no signs of currying in IL code. + // Moreover Visual Studio QuickInfo shows Vector * double + + [Test] + [Category("Operators")] + public void Operators_1() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +@"static member ( |+-+ ) : int * OperatorsOverloading.Vector -> OperatorsOverloading.Vector", +"op_BarPlusMinusPlus"); + + [Test] + [Category("Operators")] + [Category("FSharpCore")] + public void Operators_2() => + TestMethodSignature(typeof(Operators), +@"( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> ('T1 -> 'T3)", +"op_ComposeLeft"); + + [Test] + [Category("Operators")] + public void Operators_3() => + TestMethodSignature(typeof(OperatorGlobalLevel), +@"( +? ) : int -> int -> int", +"op_PlusQmark"); + + #endregion + + #region UnitsOfMeasure + + [Test] + [Category("UnitsOfMeasure")] + public void UnitsOfMeasure_0() => + TestPropertySignature(typeof(UnitsOfMeasure), +@"UnitsOfMeasure.xvec : UnitsOfMeasure.vector3D", +nameof(UnitsOfMeasure.xvec)); + + [Test] + [Category("UnitsOfMeasure")] + public void UnitsOfMeasure_1() => + TestTypeSignature(typeof(UnitsOfMeasure.vector3D), +@"type UnitsOfMeasure.vector3D = {}"); + #endregion + + #region Extensions + [Test] + [Category("Extensions")] + public void Extensions_0() => + TestMethodSignature(typeof(Extensions.MyModule1.MyClass), +@"member this.G : unit -> int", nameof(Extensions.MyModule1.MyClass.G)); + + [Test] + [Category("Extensions")] + public void Extensions_1() => + TestMethodSignature(typeof(Extensions), +@"Extensions.Int32.FromString : string -> int", +"Int32.FromString"); + #endregion + } +}
\ No newline at end of file diff --git a/mdoc/mdoc.Test/FSharp/FSharpUsageFormatterTests.cs b/mdoc/mdoc.Test/FSharp/FSharpUsageFormatterTests.cs new file mode 100644 index 00000000..b980e12e --- /dev/null +++ b/mdoc/mdoc.Test/FSharp/FSharpUsageFormatterTests.cs @@ -0,0 +1,148 @@ +using Microsoft.FSharp.Core; +using Mono.Documentation.Updater; +using NUnit.Framework; + +namespace mdoc.Test +{ + [TestFixture] + [Category("FSharp")] + public class FSharpUsageFormatterTests : BasicFSharpFormatterTests<FSharpUsageFormatter> + { + private static readonly FSharpUsageFormatter fSharpUsageFormatter = new FSharpUsageFormatter(); + protected override FSharpUsageFormatter formatter => fSharpUsageFormatter; + + #region Usage + [Test] + [Category("Usage")] + [Category("Properties")] + public void PropertyUsage_0() => + TestPropertySignature(typeof(Properties.MyPropertyClass2), +@"Properties.MyPropertyClass2.Property1", +nameof(Properties.MyPropertyClass2.Property1)); + + [Test] + [Category("Usage")] + [Category("Properties")] + [Category("DiscriminatedUnions")] + public void PropertyUsage_1() => + TestPropertySignature( + typeof(DiscriminatedUnions.SizeUnion), + "DiscriminatedUnions.SizeUnion.Small", + nameof(DiscriminatedUnions.SizeUnion.Small)); + + [Test] + [Category("Usage")] + [Category("Methods")] + public void MethodUsage_0() => + TestMethodSignature(typeof(Methods.SomeType), +@"someType.SomeMethod (a, b, c)", +nameof(Methods.SomeType.SomeMethod)); + + [Test] + [Category("Usage")] + [Category("Methods")] + public void MethodUsage_1() => + TestMethodSignature(typeof(Methods.SomeType), +@"Methods.SomeType.SomeStaticMethod (a, b, c)", +nameof(Methods.SomeType.SomeStaticMethod)); + + + [Test] + [Category("Usage")] + [Category("Methods")] + public void MethodUsage_2() => + TestMethodSignature(typeof(Methods.SomeType), +@"Methods.SomeType.SomeOtherStaticMethod2 a b c", +nameof(Methods.SomeType.SomeOtherStaticMethod2)); + + [Test] + [Category("Usage")] + [Category("Methods")] + public void MethodUsage_3() => + TestMethodSignature(typeof(Methods.SomeType), +@"Methods.SomeType.SomeOtherStaticMethod3 (a, b) c d", +nameof(Methods.SomeType.SomeOtherStaticMethod3)); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_4() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"v * a", +"op_Multiply"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_5() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"- v", +"op_UnaryNegation"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_6() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"~~~ v", +"op_LogicalNot"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_7() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"start .. finish", +"op_Range"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_8() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"start .. step .. finish", +"op_RangeStep"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_9() => + TestMethodSignature(typeof(OperatorsOverloading.Vector), +"a |+-+ v", +"op_BarPlusMinusPlus"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_10() => + TestMethodSignature(typeof(Operators), +"(arg1, arg2, arg3) |||> func", +"op_PipeRight3"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void MethodUsage_11() => + TestMethodSignature(typeof(Operators), +"func <||| (arg1, arg2, arg3)", +"op_PipeLeft3"); + + [Test] + [Category("Usage")] + [Category("Methods")] + public void MethodUsage_12() => + TestMethodSignature(typeof(PatternMatching.PatternMatchingExamples), +"PatternMatching.PatternMatchingExamples.countValues list value", +"countValues"); + + [Test] + [Category("Usage")] + [Category("Operators")] + public void ConstructorUsage_0() => + TestMethodSignature(typeof(AbstractClasses.Circle), +"new AbstractClasses.Circle (x, y, radius)", +".ctor"); + #endregion + + } +}
\ No newline at end of file diff --git a/mdoc/mdoc.Test/FormatterTests.cs b/mdoc/mdoc.Test/FormatterTests.cs index bf80e633..558b5711 100644 --- a/mdoc/mdoc.Test/FormatterTests.cs +++ b/mdoc/mdoc.Test/FormatterTests.cs @@ -1,24 +1,21 @@ using NUnit.Framework; -using System; using System.Linq; -using Mono.Documentation; -using Mono.Cecil; - using mdoc.Test.SampleClasses; -using System.Linq.Expressions; - using Mono.Documentation.Updater; namespace mdoc.Test { [TestFixture ()] - public class FormatterTests + public class FormatterTests : BasicFormatterTests<CSharpMemberFormatter> { + private CSharpMemberFormatter csharpMemberFormatter = new CSharpMemberFormatter(); + protected override CSharpMemberFormatter formatter => csharpMemberFormatter; + [Test ()] public void Formatters_VerifyPrivateConstructorNull () { // this is a private constructor - var method = GetMethod<TestClass> (m => m.IsConstructor && !m.IsPublic && m.Parameters.Count () == 1); + var method = GetMethod (typeof(TestClass), m => m.IsConstructor && !m.IsPublic && m.Parameters.Count () == 1); MemberFormatter[] formatters = new MemberFormatter[] { @@ -28,6 +25,8 @@ namespace mdoc.Test new ILFullMemberFormatter(), new VBFullMemberFormatter (), new VBMemberFormatter(), + new FSharpMemberFormatter(), + new FSharpFullMemberFormatter(), }; var sigs = formatters.Select (f => f.GetDeclaration (method)); @@ -190,15 +189,14 @@ namespace mdoc.Test [Test] public void Params() { - var member = GetMethod<TestClass> (m => m.Name == "DoSomethingWithParams"); - var formatter = new CSharpMemberFormatter (); + var member = GetMethod (typeof(TestClass), m => m.Name == "DoSomethingWithParams"); var sig = formatter.GetDeclaration (member); Assert.AreEqual ("public void DoSomethingWithParams (params int[] values);", sig); } [Test] public void IL_RefAndOut () { - var member = GetMethod<TestClass> (m => m.Name == "RefAndOut"); + var member = GetMethod (typeof(TestClass), m => m.Name == "RefAndOut"); var formatter = new ILFullMemberFormatter (); var sig = formatter.GetDeclaration (member); Assert.AreEqual (".method public hidebysig instance void RefAndOut(int32& a, [out] int32& b) cil managed", sig); @@ -234,7 +232,7 @@ namespace mdoc.Test void TestOp (string name, string expectedSig, int argCount, string returnType = "TestClass") { - var member = GetMethod<TestClass> (m => m.Name == $"op_{name}" && m.Parameters.Count == argCount && m.ReturnType.Name == RealTypeName (returnType)); + var member = GetMethod (typeof(TestClass), m => m.Name == $"op_{name}" && m.Parameters.Count == argCount && m.ReturnType.Name == RealTypeName (returnType)); var formatter = new CSharpMemberFormatter (); var sig = formatter.GetDeclaration (member); Assert.AreEqual (expectedSig, sig); @@ -243,42 +241,13 @@ namespace mdoc.Test void TestMod (string name, string expectedSig, int argCount = 1, string returnType = "SomeClass") { var member = GetMethod ( - GetType ("SampleClasses/cppcli.dll", "cppcli.SomeInterface"), - m => m.Name == name + GetType ("SampleClasses/cppcli.dll", "cppcli.SomeInterface"), + m => m.Name == name ); var formatter = new CSharpMemberFormatter (); var sig = formatter.GetDeclaration (member); Assert.AreEqual (expectedSig, sig); } - - MethodDefinition GetMethod<T> (Func<MethodDefinition, bool> query) - { - var type = typeof (T); - var moduleName = type.Module.FullyQualifiedName; - return GetMethod (GetType (moduleName, type.FullName), query); - } - - MethodDefinition GetMethod (TypeDefinition testclass, Func<MethodDefinition, bool> query) - { - var methods = testclass.Methods; - var member = methods.FirstOrDefault (query).Resolve (); - if (member == null) - throw new Exception ("Did not find the member in the test class"); - return member; - } - - TypeDefinition GetType (string filepath, string classname) - { - var module = ModuleDefinition.ReadModule (filepath); - var types = module.GetTypes (); - var testclass = types - .SingleOrDefault (t => t.FullName == classname); - if (testclass == null) - { - throw new Exception ($"Test was unable to find type {classname}"); - } - return testclass.Resolve (); - } -#endregion + #endregion } } diff --git a/mdoc/mdoc.Test/VBFormatterTests.cs b/mdoc/mdoc.Test/VBFormatterTests.cs index 7e2bf83a..de853856 100644 --- a/mdoc/mdoc.Test/VBFormatterTests.cs +++ b/mdoc/mdoc.Test/VBFormatterTests.cs @@ -1,15 +1,15 @@ -using System; -using System.Linq; using mdoc.Test.SampleClasses; -using Mono.Cecil; using Mono.Documentation.Updater; using NUnit.Framework; namespace mdoc.Test { [TestFixture()] - public class VBFormatterTests + public class VBFormatterTests : BasicFormatterTests<VBMemberFormatter> { + private VBMemberFormatter vbMemberFormatter = new VBMemberFormatter(); + protected override VBMemberFormatter formatter => vbMemberFormatter; + [Test] public void VB_op_Addition() => TestBinaryOp("Addition", "+"); @@ -118,7 +118,7 @@ namespace mdoc.Test [Test] public void Params() { - var member = GetMethod<TestClass>(m => m.Name == "DoSomethingWithParams"); + var member = GetMethod(typeof(TestClass), m => m.Name == "DoSomethingWithParams"); var formatter = new VBMemberFormatter(); var sig = formatter.GetDeclaration(member); Assert.AreEqual("Public Sub DoSomethingWithParams (ParamArray values As Integer())", sig); @@ -156,40 +156,11 @@ namespace mdoc.Test void TestOp(string name, string expectedSig, int argCount, string returnType = "TestClass") { - var member = GetMethod<TestClass>(m => m.Name == $"op_{name}" && m.Parameters.Count == argCount && m.ReturnType.Name == RealTypeName(returnType)); - var formatter = new VBMemberFormatter(); + var member = GetMethod(typeof(TestClass), m => m.Name == $"op_{name}" && m.Parameters.Count == argCount && m.ReturnType.Name == RealTypeName(returnType)); var sig = formatter.GetDeclaration(member); Assert.AreEqual(expectedSig, sig); } - MethodDefinition GetMethod<T>(Func<MethodDefinition, bool> query) - { - var type = typeof(T); - var moduleName = type.Module.FullyQualifiedName; - return GetMethod(GetType(moduleName, type.FullName), query); - } - - MethodDefinition GetMethod(TypeDefinition testclass, Func<MethodDefinition, bool> query) - { - var methods = testclass.Methods; - var member = methods.FirstOrDefault(query).Resolve(); - if (member == null) - throw new Exception("Did not find the member in the test class"); - return member; - } - - TypeDefinition GetType(string filepath, string classname) - { - var module = ModuleDefinition.ReadModule(filepath); - var types = module.GetTypes(); - var testclass = types - .SingleOrDefault(t => t.FullName == classname); - if (testclass == null) - { - throw new Exception($"Test was unable to find type {classname}"); - } - return testclass.Resolve(); - } #endregion } }
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/AbstractClasses.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/AbstractClasses.fs new file mode 100644 index 00000000..2069fb4d --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/AbstractClasses.fs @@ -0,0 +1,66 @@ +module AbstractClasses + +// An abstract class that has some methods and properties defined +// and some left abstract. +[<AbstractClass>] +type Shape2D(x0 : float, y0 : float) = + let mutable x, y = x0, y0 + let mutable rotAngle = 0.0 + + // These properties are not declared abstract. They + // cannot be overriden. + member this.CenterX with get() = x and set xval = x <- xval + + // These properties are abstract, and no default implementation + // is provided. Non-abstract derived classes must implement these. + abstract Area : float with get + + // This method is not declared abstract. It cannot be + // overriden. + member this.Move dx dy = + x <- x + dx + y <- y + dy + + + // An abstract method that is given a default implementation + // is equivalent to a virtual method in other .NET languages. + // Rotate changes the internal angle of rotation of the square. + // Angle is assumed to be in degrees. + abstract member Rotate: float -> unit + default this.Rotate(angle) = rotAngle <- rotAngle + angle + + abstract member Rotate2: float -> unit + member this.Rotate3: float -> unit = fun(ff) -> () + + + +type Square(x, y, sideLengthIn) = + inherit Shape2D(x, y) + member this.SideLength = sideLengthIn + override this.Area = this.SideLength * this.SideLength + override this.Rotate2(angle) = () + +type Circle(x, y, radius) = + inherit Shape2D(x, y) + let PI = 3.141592654 + member this.Radius = radius + override this.Area = PI * this.Radius * this.Radius + // Rotating a circle does nothing, so use the wildcard + // character to discard the unused argument and + // evaluate to unit. + override this.Rotate(_) = () + //override this.Name = "Circle" + override this.Rotate2(angle) = () + +let square1 = new Square(0.0, 0.0, 10.0) +let circle1 = new Circle(0.0, 0.0, 5.0) +circle1.CenterX <- 1.0 +square1.Move -1.0 2.0 +square1.Rotate 45.0 +circle1.Rotate 45.0 + +let shapeList : list<Shape2D> = [ (square1 :> Shape2D); + (circle1 :> Shape2D) ] +List.iter (fun (elem : Shape2D) -> + printfn "Area of %s: %f" (elem.ToString()) (elem.Area)) + shapeList
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Accessibility.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Accessibility.fs new file mode 100644 index 00000000..90eb2aeb --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Accessibility.fs @@ -0,0 +1,28 @@ +module Accessibility + +// This type is not usable outside of this file +type private MyPrivateType() = + // x is private since this is an internal let binding + let x = 5 + // X is private and does not appear in the QuickInfo window + // when viewing this type in the Visual Studio editor + member private this.X() = 10 + member this.Z() = x * 100 + +type internal MyInternalType() = + let x = 5 + member private this.X() = 10 + member this.Z() = x * 100 + +// Top-level let bindings are public by default, +// so "private" and "internal" are needed here since a +// value cannot be more accessible than its type. +let private myPrivateObj = new MyPrivateType() +let internal myInternalObj = new MyInternalType() + +// let bindings at the top level are public by default, +// so result1 and result2 are public. +let result1 = myPrivateObj.Z +let result2 = myInternalObj.Z + + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/AccessibilityTest.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/AccessibilityTest.fs new file mode 100644 index 00000000..4fd4fb9a --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/AccessibilityTest.fs @@ -0,0 +1,10 @@ +module AccessibilityTest + +open Accessibility + +// The following line is an error because private means +// that it cannot be accessed from another file or module +// let private myPrivateObj = new MyPrivateType() +let internal myInternalObj = new MyInternalType() + +let result = myInternalObj.Z
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Animals.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Animals.fs new file mode 100644 index 00000000..8cc5ae6c --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Animals.fs @@ -0,0 +1,17 @@ +module Animals + +// Call a base class from a derived one. +type Animal() = + member __.Rest() = () + +type Dog() = + inherit Animal() + member __.Run() = + base.Rest() + +// Upcasting is denoted by :> operator. +let dog = Dog() +let animal = dog :> Animal + +//Dynamic downcasting (:?>) might throw an InvalidCastException if the cast doesn't succeed at runtime. +let shouldBeADog = animal :?> Dog diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/AssemblyInfo.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/AssemblyInfo.fs new file mode 100644 index 00000000..c2f7d9f7 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/AssemblyInfo.fs @@ -0,0 +1,41 @@ +namespace mdoc.Test.FSharp.AssemblyInfo + +open System.Reflection +open System.Runtime.CompilerServices +open System.Runtime.InteropServices + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[<assembly: AssemblyTitle("mdoc.Test.FSharp")>] +[<assembly: AssemblyDescription("")>] +[<assembly: AssemblyConfiguration("")>] +[<assembly: AssemblyCompany("EPAM Systems")>] +[<assembly: AssemblyProduct("mdoc.Test.FSharp")>] +[<assembly: AssemblyCopyright("Copyright © EPAM Systems 2017")>] +[<assembly: AssemblyTrademark("")>] +[<assembly: AssemblyCulture("")>] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[<assembly: ComVisible(false)>] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[<assembly: Guid("979f9f80-12fe-4236-9e93-6d554ab13701")>] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [<assembly: AssemblyVersion("1.0.*")>] +[<assembly: AssemblyVersion("1.0.0.0")>] +[<assembly: AssemblyFileVersion("1.0.0.0")>] + +do + ()
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Attributes.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Attributes.fs new file mode 100644 index 00000000..65cf8cbb --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Attributes.fs @@ -0,0 +1,22 @@ +module Attributes + +open System + + +type OwnerAttribute(name : string) = + inherit System.Attribute() + +type CompanyAttribute(name : string) = + inherit System.Attribute() + + +[<Owner("Jason Carlson")>] +[<Company("Microsoft")>] +type SomeType1 = class end + + + +[<AttributeUsage(AttributeTargets.Event ||| AttributeTargets.Module ||| AttributeTargets.Delegate, AllowMultiple = false)>] +type TypeWithFlagAttribute = class + member this.X = "F#" +end
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/ClassMembers.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/ClassMembers.fs new file mode 100644 index 00000000..99476946 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/ClassMembers.fs @@ -0,0 +1,27 @@ +module ClassMembers + +type PointWithCounter(a: int, b: int) = + // A variable i. + let mutable i = 0 + + // A let binding that uses a pattern. + let (x, y) = (a, b) + + // A private function binding. + let privateFunction x y = x * x + 2*y + + // A static let binding. + static let mutable count = 0 + + // A do binding. + do + count <- count + 1 + + member this.Prop1 = x + member this.Prop2 = y + member this.CreatedCount = count + member this.FunctionValue = privateFunction x y + +let point1 = PointWithCounter(10, 52) + +printfn "%d %d %d %d" (point1.Prop1) (point1.Prop2) (point1.CreatedCount) (point1.FunctionValue)
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Collections.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Collections.fs new file mode 100644 index 00000000..53f945df --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Collections.fs @@ -0,0 +1,6 @@ +module Collections +open FSharp.Collections + +let f (x:Map<int, int>) = 0 + +let f2 (x:seq<int>) = 0 diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Constraints.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Constraints.fs new file mode 100644 index 00000000..a80aed38 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Constraints.fs @@ -0,0 +1,86 @@ +module Constraints + +// Base Type Constraint +type Class1<'T when 'T :> System.Exception>() = + class end + +// Interface Type Constraint +type Class2<'T when 'T :> System.IComparable>() = + class end + +// Interface Type Constraint +type Class2_1<'T when 'T :> System.IComparable and 'T :> System.Exception>() = + class end + +// Null constraint +type Class3<'T when 'T : null>() = + class end + +// Member constraint with static member +type Class4<'T when 'T : (static member staticMethod1 : unit -> 'T) >() = + class end + +// Member constraint with instance member +type Class5<'T when 'T : (member Method1 : 'T -> int)>() = + class end + +// Member constraint with property +type Class6<'T when 'T : (member Property1 : int)>() = + class end + +// Constructor constraint +type Class7<'T when 'T : (new : unit -> 'T)>() = + class end + //member val Field = new 'T() + +// Reference type constraint +type Class8<'T when 'T : not struct>() = + class end + +// Enumeration constraint with underlying value specified +type Class9<'T when 'T : enum<uint32>>() = + class end + +// 'T must implement IComparable, or be an array type with comparable +// elements, or be System.IntPtr or System.UIntPtr. Also, 'T must not have +// the NoComparison attribute. +type Class10<'T when 'T : comparison>() = + class end + +// 'T must support equality. This is true for any type that does not +// have the NoEquality attribute. +type Class11<'T when 'T : equality>() = + class end + +type Class12<'T when 'T : delegate<obj * System.EventArgs, unit>>() = + class end + +type Class13<'T when 'T : unmanaged>() = + class end + +// If there are multiple constraints, use the and keyword to separate them. +type Class14<'T,'U when 'T : equality and 'U : equality>() = + class end + +type Class15() = class + // Member constraints with two type parameters + // Most often used with static type parameters in inline functions + static member inline add(value1 : ^T when ^T : (static member (+) : ^T * ^T -> ^T), value2: ^T) = + value1 + value2 + + // ^T and ^U must support operator + + static member inline heterogenousAdd(value1 : ^T when (^T or ^U) : (static member (+) : ^T * ^U -> ^T), value2 : ^U) = + value1 + value2 +end + +type Class16() = class + static member inline method(value1 : ^T when ^T : (static member (+) : ^T * ^T -> ^T), value2: ^T) = () +end + +type Class17() = class + static member method<'T when 'T : null>(value1 : 'T, value2: 'T) = () +end + +type Class18() = class + static member method(value1 : ^T, value2: ^T) = () +end
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Constructors.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Constructors.fs new file mode 100644 index 00000000..4d60f190 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Constructors.fs @@ -0,0 +1,315 @@ +module Constructors + +type MyClass(x0, y0, z0) = + let mutable x = x0 + let mutable y = y0 + let mutable z = z0 + do + printfn "Initialized object that has coordinates (%d, %d, %d)" x y z + member this.X with get() = x and set(value) = x <- value + member this.Y with get() = y and set(value) = y <- value + member this.Z with get() = z and set(value) = z <- value + new() = MyClass(0, 0, 0) + +type MyClassObjectParameters(x0:string, y0, z0) = + let mutable x = x0 + let mutable y = y0 + let mutable z = z0 + member this.X with get() = x and set(value) = x <- value + member this.Y with get() = y and set(value) = y <- value + member internal this.Z with get() = z and set(value) = z <- value + +// new() = MyClassObjectParameters("", 0, 0) +// new(x0:string) = MyClassObjectParameters("", x0, x0) + +type MyStruct = + struct + val X : int + val Y : int + val Z : int + new(x, y, z) = { X = x; Y = y; Z = z } + end + +let myStructure1 = new MyStruct(1, 2, 3) + + +// Error Each argument of the primary constructor for a struct must be given a type, +// for example 'type S(x1:int, x2: int) = ...'. +// These arguments determine the fields of the struct + +type MyStruct2 = + struct + [<DefaultValue>] + val mutable X : int + + [<DefaultValue>] + val mutable Y : int + + [<DefaultValue>] + val mutable Z : int + end + +let myStructure2 = new MyStruct2() + + + +type MyClass3 = + val a : int + val b : int + // The following version of the constructor is an error + // because b is not initialized. + // new (a0, b0) = { a = a0; } + // The following version is acceptable because all fields are initialized. + new(a0, b0) = { a = a0; b = b0; } + + +type MyClass3_1 (a0, b0)= + let a : int = a0 + let b : int = b0 + //val c : int + +type MyClass3_2 = + val a : int + member this.b : int = 19 + +type MyClass3_3() = + [<DefaultValue>] val mutable internal a : int + [<DefaultValue>] val mutable b : int + +type MyClass3_4 (a0, b0) = + [<DefaultValue>] val mutable a : int + [<DefaultValue>] val mutable b : int + +let myClassObj = new MyClass3(35, 22) +printfn "%d %d" (myClassObj.a) (myClassObj.b) + +// type MyStruct3 (a0, b0) = +// Each argument of the primary constructor for a struct must be given a type, +// for example 'type S(x1:int, x2: int) = ...'. +// These arguments determine the fields of the struct +type MyStruct33 (a0:int, b0:int) = + struct + [<DefaultValue>] val mutable a : int + [<DefaultValue>] val mutable b : int + + new (a0:int) = MyStruct33(a0, 0) + new (a0:int, b0:int, c0:int) = MyStruct33(a0, b0) + end + +let myStruct = new MyStruct33() +let myStruct2 = new MyStruct33(10, 15) + +type MyStruct44 (a0:int, b0:int) = + struct + [<DefaultValue>] val mutable a : int + [<DefaultValue>] val mutable b : int + end + + +type MyStruct55 (a0:int, b0:int) = + struct + [<DefaultValue>] val mutable a : int + [<DefaultValue>] val mutable b : int + new (a0:int) = MyStruct55(34, 12) //then {this.a = 71} + end + +type MyStruct66 = + struct + val a : int + val b : int + new (a0:int) = {a = a0; b = 83} + end + +type MyStruct77 = + struct + [<DefaultValue>] val mutable a : int + val b : int +// new (a0:int) = {b = 83; a = 12} // doesn't work + new (a0:int) = {b = 83} + end + +type MyStruct88 = + struct + [<DefaultValue>] val mutable a : int + val b : int +// new (a0:int) = {b = 83; a = 12} // doesn't work + new (a0:int) = {b = 83} + new (a0:int, b0:int) = {b = 87} + end + + + +type PetData = { + name : string + age : int + animal : string +} + +type Pet(name:string, age:int, animal:string) = + let mutable age = age + let mutable animal = animal + + new (name:string) = + Pet(name, 5, "dog") + + new (data:PetData) = + Pet(data.name, data.age, data.animal) then System.Console.WriteLine("Pet created from PetData") + + + +type public MyType = + val private myvar: int + val private myvar2: string + + new () = + for i in 1 .. 10 do + printfn "Before field assignments %i" i + { myvar = 1; myvar2 = "test" } + then + for i in 1 .. 10 do + printfn "After field assignments %i" i + + + + +//A primary constructor in a class can execute code in a do binding. +// However, what if you have to execute code in an additional constructor, without a do binding? +// To do this, you use the then keyword. + + // Executing side effects in the primary constructor and +// additional constructors. +type Person(nameIn : string, idIn : int) = + let mutable name = nameIn + let mutable id = idIn + do printfn "Created a person object." + member this.Name with get() = name and set(v) = name <- v + member this.ID with get() = id and set(v) = id <- v + new() = + Person("Invalid Name", -1) + then + printfn "Created an invalid person object." + new(person : Person) = + Person(person.Name, person.ID) + then + printfn "Created a copy of person object." + +let person1 = new Person("Humberto Acevedo", 123458734) +let person2 = new Person() +let person3 = new Person(person1) + + + + +// Self Identifiers in Constructors +// In other members, you provide a name for the current +// object in the definition of each member. +// You can also put the self identifier on the first line of the class definition +// by using the as keyword immediately following the constructor parameters. +// The following example illustrates this syntax.+ +type MyClass1(x) as this = + // This use of the self identifier produces a warning - avoid. + let x1 = this.X + // This use of the self identifier is acceptable. + do printfn "Initializing object with X =%d" this.X + member this.X = x + + + +// In additional constructors, you can also define a self identifier +// by putting the as clause right after the constructor parameters. +// The following example illustrates this syntax. +type MyClass2(x : int) = + member this.X = x + new() as this = MyClass2(0) then printfn "Initializing with X = %d" this.X + + + +// Assigning Values to Properties at Initialization +// You can assign values to the properties of a class object in the initialization code +// by appending a list of assignments of the form property = value +// to the argument list for a constructor. This is shown in the following code example. +type Account() = + let mutable balance = 0.0 + let mutable number = 0 + let mutable firstName = "" + let mutable lastName = "" + member this.AccountNumber + with get() = number + and set(value) = number <- value + member this.FirstName + with get() = firstName + and set(value) = firstName <- value + member this.LastName + with get() = lastName + and set(value) = lastName <- value + member this.Balance + with get() = balance + and set(value) = balance <- value + member this.Deposit(amount: float) = this.Balance <- this.Balance + amount + member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount + + +let account1 = new Account(AccountNumber=8782108, + FirstName="Darren", LastName="Parker", + Balance=1543.33) + + + + +// The following version of the previous code illustrates the combination +// of ordinary arguments, optional arguments, and property settings in one constructor call. +type Account2(accountNumber : int, ?first: string, ?last: string, ?bal : float) = + let mutable balance = defaultArg bal 0.0 + let mutable number = accountNumber + let mutable firstName = defaultArg first "" + let mutable lastName = defaultArg last "" + member this.AccountNumber + with get() = number + and set(value) = number <- value + member this.FirstName + with get() = firstName + and set(value) = firstName <- value + member this.LastName + with get() = lastName + and set(value) = lastName <- value + member this.Balance + with get() = balance + and set(value) = balance <- value + member this.Deposit(amount: float) = this.Balance <- this.Balance + amount + member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount + + +let account2 = new Account2(8782108, bal = 543.33, + FirstName="Raman", LastName="Iyer") + + + +// Constructors and Inheritance +type MyClassBase2(x: int) = + let mutable z = x * x + do for i in 1..z do printf "%d " i + + +type MyClassDerived2(y: int) = + inherit MyClassBase2(y * 2) + do for i in 1..y do printf "%d " i + + +// In the case of multiple constructors, the following code can be used. +// The first line of the derived class constructors is the inherit clause, +// and the fields appear as explicit fields that are declared with the val keyword. +// For more information, see Explicit Fields: The val Keyword.+ +type BaseClass = + val string1 : string + new (str) = { string1 = str } + new () = { string1 = "" } + +type DerivedClass = + inherit BaseClass + + val string2 : string + new (str1, str2) = { inherit BaseClass(str1); string2 = str2 } + new (str2) = { inherit BaseClass(); string2 = str2 } + +let obj1 = DerivedClass("A", "B") +let obj2 = DerivedClass("A") diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Customers.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Customers.fs new file mode 100644 index 00000000..6f238cf7 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Customers.fs @@ -0,0 +1,13 @@ +module Customers + + +// Another way of implementing interfaces is to use object expressions. +type ICustomer = + abstract Name : string + abstract Age : int + +let createCustomer name age = + { new ICustomer with + member __.Name = name + member __.Age = age } + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Delegates.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Delegates.fs new file mode 100644 index 00000000..9dd69796 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Delegates.fs @@ -0,0 +1,119 @@ +module Delegates + +// The following code shows the syntax for creating delegates that represent various methods in a class. +// Depending on whether the method is a static method or an instance method, +// and whether it has arguments in the tuple form or the curried form, +// the syntax for declaring and assigning the delegate is a little different. + +type Test1() = + static member add(a : int, b : int) = + a + b + static member add2 (a : int) (b : int) = + a + b + + member x.Add(a : int, b : int) = + a + b + member x.Add2 (a : int) (b : int) = + a + b + +let replicate n c = String.replicate n (string c) + + +// Delegate specifications must not be curried types. +// Use 'typ * ... * typ -> typ' for multi-argument delegates, +// and 'typ -> (typ -> typ)' for delegates returning function values. + +type Delegate1 = delegate of (int * int) -> int// Delegate1 works with tuple arguments. +type Delegate2 = delegate of int * int -> int // Delegate2 works with curried arguments. +type Delegate3 = delegate of int * char -> string +type Delegate4 = delegate of int -> (int -> char) +type Delegate5 = delegate of int -> (int -> char -> string) +type Delegate6 = delegate of (int -> float) -> char +type Delegate7 = delegate of (int -> char -> string) -> float +type Delegate8 = delegate of int -> char +type Delegate9 = delegate of (int * int) -> char +type Delegate10 = delegate of int * int -> char +type Delegate11 = delegate of char -> unit +type Delegate12 = delegate of unit -> char +type Delegate13 = delegate of (int -> char -> string -> decimal) -> float + + +let function1(i : int, i2 : int) = 1 +let function2(i : int) (ch : int) = 1 +let function3(i : int) (s : char) = "" +let function4(i : int) (ch : int) = ' ' +let function5(i : int) (i2 : int) (ch : char) = "" +let function6(intIntFunction : int -> float) = ' ' +let function7(intCharStringFunction : int -> char -> string) = 0.5 +let function8(i : int) = ' ' +let function9(i : (int * int)) = ' ' +let function10(i : int) (i2 : int) = ' ' +let function11(c : char) = () +let function12(c : unit) = ' ' +let function12_1() = ' ' +let function13(intCharStringDecimalFunction : int -> char -> string -> decimal) = 0.5 + +let delObject1 = new Delegate1(function1) +let delObject2 = new Delegate2(function2) +let delObject3 = new Delegate3(function3) +let delObject4 = new Delegate4(function4) +let delObject5 = new Delegate5(function5) +let delObject6 = new Delegate6(function6) +let delObject7 = new Delegate7(function7) +let delObject8 = new Delegate8(function8) +let delObject9 = new Delegate9(function9) +let delObject10 = new Delegate10(function10) +let delObject11 = new Delegate11(function11) +let delObject12 = new Delegate12(function12) +let delObject12_1 = new Delegate12(function12_1) +let delObject13 = new Delegate13(function13) + + + + + +let InvokeDelegate1 (dlg : Delegate1) (a : int) (b: int) = + dlg.Invoke(a, b) +let InvokeDelegate2 (dlg : Delegate2) (a : int) (b: int) = + dlg.Invoke(a, b) + +// For static methods, use the class name, the dot operator, and the +// name of the static method. +let del1 : Delegate1 = new Delegate1( Test1.add ) +let del2 : Delegate2 = new Delegate2( Test1.add2 ) + +let testObject = Test1() + +// For instance methods, use the instance value name, the dot operator, and the instance method name. +let del3 : Delegate1 = new Delegate1( testObject.Add ) +let del4 : Delegate2 = new Delegate2( testObject.Add2 ) + +for (a, b) in [ (100, 200); (10, 20) ] do + printfn "%d + %d = %d" a b (InvokeDelegate1 del1 a b) + printfn "%d + %d = %d" a b (InvokeDelegate2 del2 a b) + printfn "%d + %d = %d" a b (InvokeDelegate1 del3 a b) + printfn "%d + %d = %d" a b (InvokeDelegate2 del4 a b) + +// The following code shows some of the different ways you can work with delegates. + + +// An F# function value constructed from an unapplied let-bound function +let function1_ = replicate + +// A delegate object constructed from an F# function value +let delObject = new Delegate3(function1_) + +// An F# function value constructed from an unapplied .NET member +let functionValue = delObject.Invoke + +List.map (fun c -> functionValue(5,c)) ['a'; 'b'; 'c'] +|> List.iter (printfn "%s") + +// Or if you want to get back the same curried signature +let replicate' n c = delObject.Invoke(n,c) + +// You can pass a lambda expression as an argument to a function expecting a compatible delegate type +// System.Array.ConvertAll takes an array and a converter delegate that transforms an element from +// one type to another according to a specified function. +let stringArray = System.Array.ConvertAll([|'a';'b'|], fun c -> replicate' 3 c) +printfn "%A" stringArray diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/DiscriminatedUnions.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/DiscriminatedUnions.fs new file mode 100644 index 00000000..fe6f8e63 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/DiscriminatedUnions.fs @@ -0,0 +1,18 @@ +module DiscriminatedUnions + +//The preceding code declares a discriminated union Shape, +// which can have values of any of three cases: Rectangle, Circle, and Prism. +// Each case has a different set of fields. +type Shape = + | Rectangle of width : float * length : float + | Circle of radius : float + | Prism of width : float * float * height : float + +let rect = Rectangle(length = 1.3, width = 10.0) +let circ = Circle (1.0) +let prism = Prism(5., 2.0, height = 3.0) + + +type SizeUnion = Small | Medium | Large // union +type ColorEnum = Red=5 | Yellow=7 | Blue=9 // enum + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/DoBindings.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/DoBindings.fs new file mode 100644 index 00000000..8da284e8 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/DoBindings.fs @@ -0,0 +1,16 @@ +module DoBindings + +open System + +type MyBindingType(a:int, b:int) as this = + inherit Object() + let x = 2*a + let y = 2*b + do printfn "Initializing object %d %d %d %d %d %d" + a b x y (this.Prop1) (this.Prop2) + static do printfn "Initializing MyBindingType." + member this.Prop1 = 4*x + member this.Prop2 = 4*y + override this.ToString() = System.String.Format("{0} {1}", this.Prop1, this.Prop2) + +let obj1 = new MyBindingType(1, 2)
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Enumerations.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Enumerations.fs new file mode 100644 index 00000000..5b5a8bb5 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Enumerations.fs @@ -0,0 +1,10 @@ +module Enumerations + +// Declaration of an enumeration. +type Color = + | Red = 0 + | Green = 1 + | Blue = 2 + +// Use of an enumeration. +let col1 : Color = Color.Red
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Extensions.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Extensions.fs new file mode 100644 index 00000000..cb5c52b6 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Extensions.fs @@ -0,0 +1,31 @@ +module Extensions + +module MyModule1 = + + // Define a type. + type MyClass() = + member this.F() = 100 + + // Define type extension. + type MyClass with + member this.G() = 200 + +module MyModule2 = + let function1 (obj1: MyModule1.MyClass) = + // Call an ordinary method. + printfn "%d" (obj1.F()) + // Call the extension method. + printfn "%d" (obj1.G()) + +// Define a new member method FromString on the type Int32. +type System.Int32 with + member this.FromString( s : string ) = + System.Int32.Parse(s) + +let testFromString str = + let mutable i = 0 + // Use the extension method. + i <- i.FromString(str) + printfn "%d" i + +testFromString "500"
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/FlexibleTypes.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/FlexibleTypes.fs new file mode 100644 index 00000000..0e06b9bf --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/FlexibleTypes.fs @@ -0,0 +1,10 @@ +module FlexibleTypes + +let iterate1 (f : unit -> seq<int>) = + for e in f() do printfn "%d" e +let iterate2 (f : unit -> #seq<int>) = + for e in f() do printfn "%d" e +let iterate3<'T when 'T :> seq<int>> (f : unit -> 'T) = () +let iterate4<'T when 'T :> Customers.ICustomer> (f : unit -> 'T) = () + + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Functions.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Functions.fs new file mode 100644 index 00000000..58c6ee6e --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Functions.fs @@ -0,0 +1,33 @@ +module Functions + +// You define functions by using the let keyword, or, if the function is recursive, the let rec keyword combination.+ +let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2) + +let rec public publicLet n = if n < 2 then 1 else fib (n - 1) + fib (n - 2) + +// Functions in F# can be composed from other functions. +// The composition of two functions function1 and function2 is another function that represents the application of function1 followed the application of function2: +let function1 x = x + 1 +let function2 x2 = x2 * 2 +let function3 (x3) = x3 * 2 +let function4 x4 y4 = x4 + y4 +let function5 (x5, y5) = x5 + y5 +let function6 (x6, y6) = () +let function7 x7 (y7, z7) = () +let function8 x8 y8 z8 = () +let function9 (x9, y9) (z9, a9) = () +let function10<'a> (x, y) (z, a) = () +let function11<'a> (x, y, z) (a, b) = () +let function12<'a> x (a, b, c, d, e) = () +let function13<'a> (a:'a) = () + +let h = function1 >> function2 +let result5 = h 100 + +//Pipelining enables function calls to be chained together as successive operations. Pipelining works as follows: +let result = 100 |> function1 |> function2 + +type TestFunction() = + member this.f13 : 'a -> unit = function13 + // member this.f13<'a> : 'a -> unit = function13 // Error FS0671 A property cannot have explicit type parameters. Consider using a method instead. +
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Generics.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Generics.fs new file mode 100644 index 00000000..c9a35b05 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Generics.fs @@ -0,0 +1,28 @@ +module Generics + +// In the following code example, makeList is generic, +// even though neither it nor its parameters are explicitly declared as generic. +let makeList a b = [a; b] + +// You can also make a function generic by using the single quotation mark syntax +// in a type annotation to indicate that a parameter type is a generic type parameter. +// In the following code, function1 is generic because its parameters are declared in this manner, as type parameters. +let function1 (x: 'a) (y: 'a) = + printfn "%A %A" x y + +// You can also make a function generic by explicitly +// declaring its type parameters in angle brackets (<type-parameter>) +let function2<'T> x y = + printfn "%A, %A" x y + + +type Map2<[<EqualityConditionalOn>]'Key,[<EqualityConditionalOn>][<ComparisonConditionalOn>]'Value when 'Key : comparison and 'Value : comparison> = class + //member this.Item ('Key) : 'Value (requires comparison) +// member Item : key:'Key -> 'Value with get + member this.fffff : option<int> = None + member this.l : list<int> = [ 1; 2; 3 ] + member this.c : Choice<int, float> = Choice1Of2 0 + member this.c2 : Choice<int, float> = Choice2Of2 0.5 + member this.r : ref<int> = ref 0 + member this.s : seq<int> = seq { for i in 1 .. 10 do yield i * i } +end diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/IndexedProperties.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/IndexedProperties.fs new file mode 100644 index 00000000..71660a10 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/IndexedProperties.fs @@ -0,0 +1,30 @@ +module IndexedProperties + +type NumberStrings() = + let mutable ordinals = [| "one"; "two"; "three"; "four"; "five"; + "six"; "seven"; "eight"; "nine"; "ten" |] + let mutable cardinals = [| "first"; "second"; "third"; "fourth"; + "fifth"; "sixth"; "seventh"; "eighth"; + "ninth"; "tenth" |] + member this.Item + with get(index) = ordinals.[index] + and set index value = ordinals.[index] <- value + member this.Ordinal + with get(index) = ordinals.[index] + and set index value = ordinals.[index] <- value + member this.Cardinal + with get(index) = cardinals.[index] + and set index value = cardinals.[index] <- value + +let nstrs = new NumberStrings() +nstrs.[0] <- "ONE" +for i in 0 .. 9 do + printf "%s " (nstrs.[i]) +printfn "" + +nstrs.Cardinal(5) <- "6th" + +for i in 0 .. 9 do + printf "%s " (nstrs.Ordinal(i)) + printf "%s " (nstrs.Cardinal(i)) +printfn ""
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Inheritance.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Inheritance.fs new file mode 100644 index 00000000..aade392d --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Inheritance.fs @@ -0,0 +1,45 @@ +module Inheritance + +//The following code example illustrates the declaration of +// a new virtual method function1 in a base class +// and how to override it in a derived class. +type MyClassBase1() = + let mutable z = 0 + abstract member function1 : int -> int + default u.function1(a : int) = z <- z + a; z + +type MyClassDerived1() = + inherit MyClassBase1() + override u.function1(a: int) = a + 1 + + +//The following code shows a base class and a derived class, +// where the derived class calls the base class constructor in the inherit clause:+ +type MyClassBase2(x: int) = + let mutable z = x * x + do for i in 1..z do printf "%d " i + +type MyClassDerived2(y: int) = + inherit MyClassBase2(y * 2) + do for i in 1..y do printf "%d " i + + + +//In the case of multiple constructors, the following code can be used. +// The first line of the derived class constructors is the inherit clause, +// and the fields appear as explicit fields that are declared with the val keyword. +// For more information, see Explicit Fields: The val Keyword. +type BaseClass = + val string1 : string + new (str) = { string1 = str } + new () = { string1 = "" } + +type DerivedClass = + inherit BaseClass + + val string2 : string + new (str1, str2) = { inherit BaseClass(str1); string2 = str2 } + new (str2) = { inherit BaseClass(); string2 = str2 } + +let obj1 = DerivedClass("A", "B") +let obj2 = DerivedClass("A")
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/InheritanceAlternative.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/InheritanceAlternative.fs new file mode 100644 index 00000000..28fd9f85 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/InheritanceAlternative.fs @@ -0,0 +1,13 @@ +module AlternativesToInheritance + +open System + +// In cases where a minor modification of a type is required, +// consider using an object expression as an alternative to inheritance. +// The following example illustrates the use of an object expression as an alternative +// to creating a new derived type: +let object1 = { new Object() with + override this.ToString() = "This overrides object.ToString()" + } + +printfn "%s" (object1.ToString())
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/InlineFunctions.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/InlineFunctions.fs new file mode 100644 index 00000000..8ccbf250 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/InlineFunctions.fs @@ -0,0 +1,16 @@ +module InlineFunctions + +// The following code example illustrates an inline function at the top level, +// an inline instance method, and an inline static method. + +let inline increment x = x + 1 +type WrapInt32() = + member inline this.incrementByOne(x) = x + 1 + static member inline Increment(x) = x + 1 + +// The presence of inline affects type inference. +// This is because inline functions can have statically resolved type parameters, +// whereas non-inline functions cannot. The following code example shows a case where inline +// is helpful because you are using a function that has a statically resolved type parameter, the float conversion operator. +let inline printAsFloatingPoint number = + printfn "%f" (float number) diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Interfaces.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Interfaces.fs new file mode 100644 index 00000000..3d279d76 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Interfaces.fs @@ -0,0 +1,52 @@ +module Interfaces + +// You can implement one or more interfaces in a class type by using the interface keyword, +// the name of the interface, and the with keyword, followed by the interface member definitions, +// as shown in the following code. +type IPrintable = + abstract member Print : unit -> unit + +type SomeClass1(x: int, y: float) = + interface IPrintable with + member this.Print() = printfn "%d %f" x y + + + +// To call the interface method when you have an object of type SomeClass, +// you must upcast the object to the interface type, as shown in the following code.+ +let x1 = new SomeClass1(1, 2.0) +(x1 :> IPrintable).Print() + + +// An alternative is to declare a method on the object that upcasts and calls the interface method, +// as in the following example. +type SomeClass2(x: int, y: float) = + member this.Print() = (this :> IPrintable).Print() + interface IPrintable with + member this.Print() = printfn "%d %f" x y + +let x2 = new SomeClass2(1, 2.0) +x2.Print() + +// Interface Inheritance +type Interface0 = interface + abstract member Method1 : int -> int +end + +// Interface Inheritance +type Interface1 = + abstract member Method1 : int -> int + +type Interface2 = + abstract member Method2 : int -> int + +type Interface3 = + inherit Interface1 + inherit Interface2 + abstract member Method3 : int -> int + +type MyClass() = + interface Interface3 with + member this.Method1(n) = 2 * n + member this.Method2(n) = n + 100 + member this.Method3(n) = n / 10
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Library1.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Library1.fs new file mode 100644 index 00000000..bea234e1 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Library1.fs @@ -0,0 +1,29 @@ +namespace mdoc.Test.FSharp + +type Class1() = + member this.X = "F#" + + member this.T = Functions.function6(1, "32") + +type ClassPipes() = + let cylinderVolume (radius : float) (length : float) : float = radius * length + let smallPipeRadius = 2.0 + let bigPipeRadius = 3.0 + + // These define functions that take the length as a remaining + // argument: + + let smallPipeVolume = cylinderVolume(smallPipeRadius) + let bigPipeVolume = cylinderVolume bigPipeRadius + + let length1 = 30.0 + let length2 = 40.0 + member this.smallPipeVol1 = smallPipeVolume length1 + member this.smallPipeVol2 = smallPipeVolume length2 + member this.bigPipeVol1 = bigPipeVolume length1 + member this.bigPipeVol2 = bigPipeVolume length2 + member this.ff = Quotations.Var.Global("", typedefof<ClassPipes>) + //member this.ff2 = Quotations.Var.Global "" typedefof<ClassPipes> + member this.ff3 = Array.blit + //member this.ff4 = Array.averageBy None None + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Literals.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Literals.fs new file mode 100644 index 00000000..afab6e32 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Literals.fs @@ -0,0 +1,27 @@ +module Literals + +[<Literal>] +let Literal1 = "a" + "b" + +[<Literal>] +let FileLocation = __SOURCE_DIRECTORY__ + "/" + __SOURCE_FILE__ + +[<Literal>] +let Literal2 = 1 ||| 64 + +[<Literal>] +let Literal3 = System.IO.FileAccess.Read ||| System.IO.FileAccess.Write + +let someSbyte = 86y + +let someByte = 86uy + +let someBigint = 9999999999999999999999999999I + +let public someDecimal = 0.7833M + +let public someChar = 'a' + +let public someString = "text\n" + + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Methods.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Methods.fs new file mode 100644 index 00000000..59fb8e6b --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Methods.fs @@ -0,0 +1,97 @@ +module Methods + +open mdoc.Test.FSharp +open Interfaces + +type SomeType(factor0: int) = + // The following example illustrates the definition and use of a non-abstract instance method. + let factor = factor0 + let mul x y = x * y + let function1 (x : int) (z9, a9) = (1, 1) + let function2 (a : int -> int, b : int) = (1, 1) + + member this.SomeMethod(a, b, c) = + (a + b + c) * factor + + member this.SomeOtherMethod(a, b, c) = + this.SomeMethod(a, b, c) * factor + + member this.SomeOtherMethod2 : int -> int * int -> int * int = function1 + member this.SomeOtherMethod3 : (int -> int) * int -> int * int = function2 + + // The following example illustrates the definition and use of static methods + static member SomeStaticMethod(a, b, c) = + (a + b + c) + + static member SomeOtherStaticMethod(a, b, c) = + SomeType.SomeStaticMethod(a, b, c) * 100 + + static member SomeOtherStaticMethod2 a b c = a + b + c + static member SomeOtherStaticMethod3 (a, b) c d = a + b + c + d + + + + member this.TestRefParam (i : int ref) = 10 + member this.Test () = SomeType.SomeOtherStaticMethod + member this.Test2 () = this.SomeMethod + + +// The following example illustrates an abstract method Rotate that has a default implementation, +// the equivalent of a .NET Framework virtual method. +type Ellipse(a0 : float, b0 : float, theta0 : float) = + let mutable axis1 = a0 + let mutable axis2 = b0 + let mutable rotAngle = theta0 + let i1 = SomeType.SomeOtherStaticMethod(1, 2, 3) + let i2 = SomeType.SomeOtherStaticMethod2 1 2 3 + let i3 = SomeType.SomeOtherStaticMethod3 (1, 2) 3 4 + + abstract member Rotate: float -> unit + default this.Rotate(delta : float) = rotAngle <- rotAngle + delta + +// The following example illustrates a derived class that overrides a base class method. In this case, the override changes the behavior so that the method does nothing. +type Circle(radius : float) = + inherit Ellipse(radius, radius, 0.0) + // Circles are invariant to rotation, so do nothing. + override this.Rotate(_) = () + +type RectangleXY(x1 : float, y1: float, x2: float, y2: float) = + // Field definitions. + let height = y2 - y1 + let width = x2 - x1 + let area = height * width + // Private functions. + static let maxFloat (x: float) (y: float) = + if x >= y then x else y + static let minFloat (x: float) (y: float) = + if x <= y then x else y + // Properties. + // Here, "this" is used as the self identifier, + // but it can be any identifier. + member this.X1 = x1 + member this.Y1 = y1 + member this.X2 = x2 + member this.Y2 = y2 + // A static method. + static member intersection(rect1 : RectangleXY, rect2 : RectangleXY) = + let x1 = maxFloat rect1.X1 rect2.X1 + let y1 = maxFloat rect1.Y1 rect2.Y1 + let x2 = minFloat rect1.X2 rect2.X2 + let y2 = minFloat rect1.Y2 rect2.Y2 + let result : RectangleXY option = + if ( x2 > x1 && y2 > y1) then + Some (RectangleXY(x1, y1, x2, y2)) + else + None + result + +// Test code. +let testIntersection = + let r1 = RectangleXY(10.0, 10.0, 20.0, 20.0) + let r2 = RectangleXY(15.0, 15.0, 25.0, 25.0) + let r3 : RectangleXY option = RectangleXY.intersection(r1, r2) + match r3 with + | Some(r3) -> printfn "Intersection rectangle: %f %f %f %f" r3.X1 r3.Y1 r3.X2 r3.Y2 + | None -> printfn "No intersection found." + +testIntersection
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Namespaces.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Namespaces.fs new file mode 100644 index 00000000..f59342a4 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Namespaces.fs @@ -0,0 +1,9 @@ +namespace Widgets + + +// The following example shows a code file that declares a namespace Widgets with a type and a module included in that namespace. +type MyWidget1 = + member this.WidgetName = "Widget1" + +module WidgetsModule = + let widgetName = "Widget2"
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/NestedModules.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/NestedModules.fs new file mode 100644 index 00000000..68b601f7 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/NestedModules.fs @@ -0,0 +1,13 @@ +module NestedModules + +// Modules can be nested. Inner modules must be indented as far as outer module declarations +// to indicate that they are inner modules, not new modules. +module Y = + let y = 1 + + [<AutoOpen>] + module Z = + let z = 5 + +module X = + let x = 2
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/NestedTypes.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/NestedTypes.fs new file mode 100644 index 00000000..f2958521 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/NestedTypes.fs @@ -0,0 +1,6 @@ +module NestedTypes + +//I suppose nested classes were not a core feature of the .NET object model +// and it was simply dropped to save the resources. There may be some technical difficulties +// (i.e. with visibility or with recursive type definitions), but I don't think that would be a major problem. + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/OperatorGlobalLevel.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/OperatorGlobalLevel.fs new file mode 100644 index 00000000..33b9f9a9 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/OperatorGlobalLevel.fs @@ -0,0 +1,9 @@ +module OperatorGlobalLevel + +// You can also define operators at the global level. +// The following code defines an operator +?. +let inline (+?) (x: int) (y: int) = x + 2*y + +let i = (+?) + +printf "%d" (10 +? 1)
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/OperatorsOverloading.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/OperatorsOverloading.fs new file mode 100644 index 00000000..f97564cd --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/OperatorsOverloading.fs @@ -0,0 +1,42 @@ +module OperatorsOverloading + +// The following code illustrates a vector class that has just two operators, one for unary minus +// and one for multiplication by a scalar. In the example, two overloads for scalar multiplication are needed +// because the operator must work regardless of the order in which the vector and scalar appear.+ +type Vector(x: float, y : float) = + member this.x = x + member this.y = y + static member (~-) (v : Vector) = + Vector(-1.0 * v.x, -1.0 * v.y) + static member (*) (v : Vector, a) = + Vector(a * v.x, a * v.y) + static member (^^^) (a, v: Vector) = + Vector(a * v.x, a * v.y) + static member (?<-) (a, v, b: Vector) = + Vector(a * b.x, a * b.y) + static member (|+-+) (a : int, v: Vector) = + Vector(0.0, 0.0) + static member ( ~~~ ) (v: Vector) = + Vector(0.0, 0.0) + static member ( + ) (v: Vector, v2: Vector) = + Vector(0.0, 0.0) + static member ( .. .. ) (start, step, finish) = + Vector(0.0, 0.0) + static member ( .. ) (start, finish) = + Vector(0.0, 0.0) + override this.ToString() = + this.x.ToString() + " " + this.y.ToString() + +let v1 = Vector(1.0, 2.0) +let v2 = v1 * 2.0 +let v4 = - v2 +let v5 = 1 |+-+ v2 +let v7 = ~~~ v4 + +printfn "%s" (v1.ToString()) +printfn "%s" (v2.ToString()) +printfn "%s" (v4.ToString()) + +let v9 : ('T2 -> 'T3) -> ('T1 -> 'T2) -> ('T1 -> 'T3) = Operators.(<<) +let v10 : ('T2 -> 'T3) -> ('T1 -> 'T2) -> ('T1 -> 'T3) = Operators.(<<) + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/PatternMatchingExamples.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/PatternMatchingExamples.fs new file mode 100644 index 00000000..0d78183f --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/PatternMatchingExamples.fs @@ -0,0 +1,235 @@ +module PatternMatching.PatternMatchingExamples + +// Patterns are rules for transforming input data. They are used throughout the F# language +// to compare data with a logical structure or structures, decompose data into constituent parts, +// or extract information from data in various ways.1 + + + +// Constant Patterns +// The following example demonstrates the use of literal patterns, and also uses a variable pattern and an OR pattern.+ +[<Literal>] +let Three = 3 + +let filter123 x = + match x with + // The following line contains literal patterns combined with an OR pattern. + | 1 | 2 | Three -> printfn "Found 1, 2, or 3!" + // The following line contains a variable pattern. + | var1 -> printfn "%d" var1 + +for x in 1..10 do filter123 x + +// Another example of a literal pattern is a pattern based on enumeration constants. +// You must specify the enumeration type name when you use enumeration constants. +type Color = + | Red = 0 + | Green = 1 + | Blue = 2 + +let printColorName (color:Color) = + match color with + | Color.Red -> printfn "Red" + | Color.Green -> printfn "Green" + | Color.Blue -> printfn "Blue" + | _ -> () + +printColorName Color.Red +printColorName Color.Green +printColorName Color.Blue + + + +// Identifier Patterns +// The option type is a discriminated union that has two cases, Some and None. One case (Some) has a value, +// but the other (None) is just a named case. Therefore, Some needs to have a variable for the value associated +// with the Some case, but None must appear by itself. In the following code, the variable var1 is given the value +// that is obtained by matching to the Some case. +let printOption (data : int option) = + match data with + | Some var1 -> printfn "%d" var1 + | None -> () + +// In the following example, the PersonName discriminated union contains a mixture of strings +// and characters that represent possible forms of names. The cases of the discriminated union are FirstOnly, +// LastOnly, and FirstLast. +type PersonName = + | FirstOnly of string + | LastOnly of string + | FirstLast of string * string + +let constructQuery personName = + match personName with + | FirstOnly(firstName) -> printf "May I call you %s?" firstName + | LastOnly(lastName) -> printf "Are you Mr. or Ms. %s?" lastName + | FirstLast(firstName, lastName) -> printf "Are you %s %s?" firstName lastName + +// For discriminated unions that have named fields, you use the equals sign (=) to extract the value of a named field. +// For example, consider a discriminated union with a declaration like the following.+ +type Shape = + | Rectangle of height : float * width : float + | Circle of radius : float + +// You can use the named fields in a pattern matching expression as follows. +let matchShape shape = + match shape with + | Rectangle(height = h) -> printfn "Rectangle with length %f" h + | Circle(r) -> printfn "Circle with radius %f" r + +// When you specify multiple fields, use the semicolon (;) as a separator.+ +let matchShape2 shape = + match shape with + | Rectangle(height = h; width = w) -> printfn "Rectangle with height %f and width %f" h w + | _ -> () + + + +// Variable Patterns +// The following example demonstrates a variable pattern within a tuple pattern.+ +let function1 x = + match x with + | (var1, var2) when var1 > var2 -> printfn "%d is greater than %d" var1 var2 + | (var1, var2) when var1 < var2 -> printfn "%d is less than %d" var1 var2 + | (var1, var2) -> printfn "%d equals %d" var1 var2 + +function1 (1,2) +function1 (2, 1) +function1 (0, 0) + + + +// as Pattern +let (var1, var2) as tuple1 = (1, 2) +printfn "%d %d %A" var1 var2 tuple1 + +// OR Pattern +let detectZeroOR point = + match point with + | (0, 0) | (0, _) | (_, 0) -> printfn "Zero found." + | _ -> printfn "Both nonzero." +detectZeroOR (0, 0) +detectZeroOR (1, 0) +detectZeroOR (0, 10) +detectZeroOR (10, 15) + +// AND Pattern +let detectZeroAND point = + match point with + | (0, 0) -> printfn "Both values zero." + | (var1, var2) & (0, _) -> printfn "First value is 0 in (%d, %d)" var1 var2 + | (var1, var2) & (_, 0) -> printfn "Second value is 0 in (%d, %d)" var1 var2 + | _ -> printfn "Both nonzero." +detectZeroAND (0, 0) +detectZeroAND (1, 0) +detectZeroAND (0, 10) +detectZeroAND (10, 15) + +// Cons Pattern +let list1 = [ 1; 2; 3; 4 ] +// This example uses a cons pattern and a list pattern. +let rec printList l = + match l with + | head :: tail -> printf "%d " head; printList tail + | [] -> printfn "" + +printList list1 + +//List Pattern +// This example uses a list pattern. +let listLength list = + match list with + | [] -> 0 + | [ _ ] -> 1 + | [ _; _ ] -> 2 + | [ _; _; _ ] -> 3 + | _ -> List.length list + +printfn "%d" (listLength [ 1 ]) +printfn "%d" (listLength [ 1; 1 ]) +printfn "%d" (listLength [ 1; 1; 1; ]) +printfn "%d" (listLength [ ] ) + +// Array Pattern +// This example uses array patterns. +let vectorLength vec = + match vec with + | [| var1 |] -> var1 + | [| var1; var2 |] -> sqrt (var1*var1 + var2*var2) + | [| var1; var2; var3 |] -> sqrt (var1*var1 + var2*var2 + var3*var3) + | _ -> failwith "vectorLength called with an unsupported array size of %d." (vec.Length) + +printfn "%f" (vectorLength [| 1. |]) +printfn "%f" (vectorLength [| 1.; 1. |]) +printfn "%f" (vectorLength [| 1.; 1.; 1.; |]) +printfn "%f" (vectorLength [| |] ) + +// Parenthesized Pattern +let countValues list value = + let rec checkList list acc = + match list with + | (elem1 & head) :: tail when elem1 = value -> checkList tail (acc + 1) + | head :: tail -> checkList tail acc + | [] -> acc + checkList list 0 + +let result = countValues [ for x in -10..10 -> x*x - 4 ] 0 +printfn "%d" result + +let countValues2<'a when 'a : equality> : List<'a> -> 'a -> int = countValues + +// Tuple Pattern +let detectZeroTuple point = + match point with + | (0, 0) -> printfn "Both values zero." + | (0, var2) -> printfn "First value is 0 in (0, %d)" var2 + | (var1, 0) -> printfn "Second value is 0 in (%d, 0)" var1 + | _ -> printfn "Both nonzero." +detectZeroTuple (0, 0) +detectZeroTuple (1, 0) +detectZeroTuple (0, 10) +detectZeroTuple (10, 15) + +// Record Pattern +// This example uses a record pattern. + +type MyRecord = { Name: string; ID: int } + +let IsMatchByName record1 (name: string) = + match record1 with + | { MyRecord.Name = nameFound; MyRecord.ID = _; } when nameFound = name -> true + | _ -> false + +let recordX = { Name = "Parker"; ID = 10 } +let isMatched1 = IsMatchByName recordX "Parker" +let isMatched2 = IsMatchByName recordX "Hartono" + + +// Wildcard Pattern +//Patterns That Have Type Annotations +let detect1 x = + match x with + | 1 -> printfn "Found a 1!" + | (var1 : int) -> printfn "%d" var1 +detect1 0 +detect1 1 + + +// Type Test Pattern +// open System.Windows.Forms +// +// let RegisterControl(control:Control) = +// match control with +// | :? Button as button -> button.Text <- "Registered." +// | :? CheckBox as checkbox -> checkbox.Text <- "Registered." +// | _ -> () + +// Null Pattern +let ReadFromFile (reader : System.IO.StreamReader) = + match reader.ReadLine() with + | null -> printfn "\n"; false + | line -> printfn "%s" line; true + +let fs = System.IO.File.Open("..\..\Program.fs", System.IO.FileMode.Open) +let sr = new System.IO.StreamReader(fs) +while ReadFromFile(sr) = true do () +sr.Close()
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Properties.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Properties.fs new file mode 100644 index 00000000..912f417c --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Properties.fs @@ -0,0 +1,24 @@ +module Properties + +type MyPropertiesType() = + let mutable myInternalValue = 0 + + // A read-only property. + member this.MyReadOnlyProperty = myInternalValue + + // A write-only property. + member this.MyWriteOnlyProperty with set (value) = myInternalValue <- value + + // A read-write property. + member this.MyReadWriteProperty + with get () = myInternalValue + and set (value) = myInternalValue <- value + +type MyPropertyClass2(property1 : int) = + member val Property1 = property1 + member val Property2 = "" with get, set + +type MyAutoPropertyClass() = + let random = new System.Random() + member val AutoProperty = random.Next() with get, set + member this.ExplicitProperty = random.Next()
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Records.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Records.fs new file mode 100644 index 00000000..6fda4288 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Records.fs @@ -0,0 +1,17 @@ +module Records + +type MyRecord = { + X: int; + Y: int; + Z: int + } + +let myRecord1 = { X = 1; Y = 2; Z = 3; } + +type Car = { + Make : string + Model : string + mutable Odometer : int + } +let myCar = { Make = "Fabrikam"; Model = "Coupe"; Odometer = 108112 } +myCar.Odometer <- myCar.Odometer + 21
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/ReferenceCells.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/ReferenceCells.fs new file mode 100644 index 00000000..c8807601 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/ReferenceCells.fs @@ -0,0 +1,10 @@ +module ReferenceCells + +// Declare a reference. +let refVar = ref 6 + +// Change the value referred to by the reference. +refVar := 50 + +// Dereference by using the ! operator. +printfn "%d" !refVar
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Script.fsx b/mdoc/mdoc.Test/mdoc.Test.FSharp/Script.fsx new file mode 100644 index 00000000..4d2a3730 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Script.fsx @@ -0,0 +1,8 @@ +// Learn more about F# at http://fsharp.org. See the 'F# Tutorial' project +// for more guidance on F# programming. + +#load "Library1.fs" +open mdoc.Test.FSharp + +// Define your library scripting code here + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Structures.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Structures.fs new file mode 100644 index 00000000..315249cf --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Structures.fs @@ -0,0 +1,36 @@ +module Structures + +type public StructureType = + struct + val x: float + end + +// or +[<StructAttribute>] +type public StructureType2 = + val x: float + + +// In Point3D, three immutable values are defined. +// x, y, and z will be initialized to 0.0. +type Point3D = + struct + val x: float + val y: float + val z: float + end + +// In Point2D, two immutable values are defined. +// Point2D has an explicit constructor. +// You can create zero-initialized instances of Point2D, or you can +// pass in arguments to initialize the values. +type Point2D = + struct + val X: float + val Y: float + new(x: float, y: float) = + { + X = x; + Y = y + } +end
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/TypeExtensions.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/TypeExtensions.fs new file mode 100644 index 00000000..1b2229fd --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/TypeExtensions.fs @@ -0,0 +1,65 @@ +module TypeExtensions + +module TypeExtensions1 = + + // Define a type. + type MyClass() = + member this.F() = 100 + + // Define type extension. + type MyClass with + member this.G() = 200 + +module TypeExtensions2 = + let function1 (obj1: TypeExtensions1.MyClass) = + // Call an ordinary method. + printfn "%d" (obj1.F()) + // Call the extension method. + printfn "%d" (obj1.G()) + + + + +// Define a new member method FromString on the type Int32. +type System.Int32 with + member this.FromString( s : string ) = + System.Int32.Parse(s) + +let testFromString str = + let mutable i = 0 + // Use the extension method. + i <- i.FromString(str) + printfn "%d" i + +testFromString "500" + + + + +// Generic Extension Methods +open System.Collections.Generic + +type IEnumerable<'T> with + /// Repeat each element of the sequence n times + member xs.RepeatElements(n: int) = + seq { for x in xs do for i in 1 .. n do yield x } + +//However, for a generic type, the type variable may not be constrained. +// You can now declare a C#-style extension member in F# to work around this limitation. +// When you combine this kind of declaration with the inline feature of F#, +// you can present generic algorithms as extension members. +// Consider the following declaration: +open System.Runtime.CompilerServices +[<Extension>] +type ExtraCSharpStyleExtensionMethodsInFSharp () = + [<Extension>] + static member inline Sum(xs: IEnumerable<'T>) = Seq.sum xs + +let listOfIntegers = [ 1 .. 100 ] +//let listOfBigIntegers = [ 1I to 100I ] +let listOfBigIntegers = [ 1I .. 100I ] +let sum1 = listOfIntegers.Sum() +let sum2 = listOfBigIntegers.Sum() +//In this code, the same generic arithmetic code is applied to lists of two types without overloading, +// by defining a single extension member.+ + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/UnitsOfMeasure.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/UnitsOfMeasure.fs new file mode 100644 index 00000000..d11dff0a --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/UnitsOfMeasure.fs @@ -0,0 +1,77 @@ +module UnitsOfMeasure + +// The previous syntax defines unit-name as a unit of measure. The optional part is used to define a new measure in terms of previously defined units. For example, the following line defines the measure cm (centimeter).+ +// Distance, cm +[<Measure>] type cm + +// The following line defines the measure ml (milliliter) as a cubic centimeter (cm^3). +// Volume, milliliters. +[<Measure>] type ml = cm^3 + + +// Mass, grams. +[<Measure>] type g +// Mass, kilograms. +[<Measure>] type kg +// Weight, pounds. +[<Measure>] type lb + +// Distance, meters. +[<Measure>] type m + +// Distance, inches. +[<Measure>] type inch +// Distance, feet +[<Measure>] type ft + +// Time, seconds. +[<Measure>] type s + +// Force, Newtons. +[<Measure>] type N = kg m / s + +// Pressure, bar. +[<Measure>] type bar +// Pressure, Pascals +[<Measure>] type Pa = N / m^2 + +// Volume, liters. +[<Measure>] type L + +// Define conversion constants. +let gramsPerKilogram : float<g kg^-1> = 1000.0<g/kg> +let cmPerMeter : float<cm/m> = 100.0<cm/m> +let cmPerInch : float<cm/inch> = 2.54<cm/inch> + +let mlPerCubicCentimeter : float<ml/cm^3> = 1.0<ml/cm^3> +let mlPerLiter : float<ml/L> = 1000.0<ml/L> + +// Define conversion functions. +let convertGramsToKilograms (x : float<g>) = x / gramsPerKilogram +let convertCentimetersToInches (x : float<cm>) = x / cmPerInch + + +// Using Generic Units +let genericSumUnits ( x : float<'u>) (y: float<'u>) = x + y + +let v1 = 3.1<m/s> +let v2 = 2.7<m/s> +let x1 = 1.2<m> +let t1 = 1.0<s> + +// OK: a function that has unit consistency checking. +let result1 = genericSumUnits v1 v2 +// Error reported: mismatched units. +// Uncomment to see error. +// let result2 = genericSumUnits v1 x1 + +// Creating Aggregate Types with Generic Units +// Define a vector together with a measure type parameter. +// Note the attribute applied to the type parameter. +type vector3D<[<Measure>] 'u> = { x : float<'u>; y : float<'u>; z : float<'u>} + +// Create instances that have two different measures. +// Create a position vector. +let xvec : vector3D<m> = { x = 0.0<m>; y = 0.0<m>; z = 0.0<m> } +// Create a velocity vector. +let v1vec : vector3D<m/s> = { x = 1.0<m/s>; y = -1.0<m/s>; z = 0.0<m/s> }
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/Vector.fs b/mdoc/mdoc.Test/mdoc.Test.FSharp/Vector.fs new file mode 100644 index 00000000..300ab454 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/Vector.fs @@ -0,0 +1,35 @@ +module SomeNamespace.SomeModule + +// This example is a basic class with (1) local let bindings, (2) properties, (3) methods, and (4) static members. +type Vector(x : float, y : float) = + let mag = sqrt(x * x + y * y) // (1) + member this.X = x // (2) + member this.Y = y + member this.Mag = mag + member this.Scale(s) = // (3) + Vector(x * s, y * s) + static member (+) (a : Vector, b : Vector) = // (4) + Vector(a.X + b.X, a.Y + b.Y) + + +// Declare IVector interface and implement it in Vector'. +type IVector = + abstract Scale : float -> IVector + +type Vector'''(x, y) = + interface IVector with + member __.Scale(s) = + Vector'''(x * s, y * s) :> IVector + member __.X = x + member __.Y = y + + + +type Vector2(x, y) = + interface IVector with + member __.Scale(s) = + Vector2(x * s, y * s) :> IVector + member __.X = x + member __.Y = y + + diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/mdoc.Test.FSharp.fsproj b/mdoc/mdoc.Test/mdoc.Test.FSharp/mdoc.Test.FSharp.fsproj new file mode 100644 index 00000000..2d15173d --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/mdoc.Test.FSharp.fsproj @@ -0,0 +1,117 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>979f9f80-12fe-4236-9e93-6d554ab13701</ProjectGuid> + <OutputType>Library</OutputType> + <RootNamespace>mdoc.Test.FSharp</RootNamespace> + <AssemblyName>mdoc.Test.FSharp</AssemblyName> + <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion> + <TargetFSharpCoreVersion>4.4.1.0</TargetFSharpCoreVersion> + <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects> + <Name>mdoc.Test.FSharp</Name> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <Tailcalls>false</Tailcalls> + <OutputPath>bin\$(Configuration)\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <WarningLevel>3</WarningLevel> + <DocumentationFile>bin\$(Configuration)\$(AssemblyName).XML</DocumentationFile> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <Tailcalls>true</Tailcalls> + <OutputPath>bin\$(Configuration)\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <WarningLevel>3</WarningLevel> + <DocumentationFile>bin\$(Configuration)\$(AssemblyName).XML</DocumentationFile> + </PropertyGroup> + <PropertyGroup> + <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion> + </PropertyGroup> + <Choose> + <When Condition="'$(VisualStudioVersion)' == '11.0'"> + <PropertyGroup Condition=" '$(FSharpTargetsPath)' == '' AND Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets') "> + <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath> + </PropertyGroup> + </When> + <Otherwise> + <PropertyGroup Condition=" '$(FSharpTargetsPath)' == '' AND Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets') "> + <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath> + </PropertyGroup> + </Otherwise> + </Choose> + <Import Project="$(FSharpTargetsPath)" /> + <ItemGroup> + <Compile Include="AssemblyInfo.fs" /> + <None Include="Script.fsx" /> + <Content Include="packages.config" /> + <Compile Include="AbstractClasses.fs" /> + <Compile Include="Accessibility.fs" /> + <Compile Include="AccessibilityTest.fs" /> + <Compile Include="Animals.fs" /> + <Compile Include="Attributes.fs" /> + <Compile Include="ClassMembers.fs" /> + <Compile Include="Collections.fs" /> + <Compile Include="Constraints.fs" /> + <Compile Include="Constructors.fs" /> + <Compile Include="Customers.fs" /> + <Compile Include="Delegates.fs" /> + <Compile Include="DiscriminatedUnions.fs" /> + <Compile Include="DoBindings.fs" /> + <Compile Include="Enumerations.fs" /> + <Compile Include="Extensions.fs" /> + <Compile Include="FlexibleTypes.fs" /> + <Compile Include="Functions.fs" /> + <Compile Include="Generics.fs" /> + <Compile Include="IndexedProperties.fs" /> + <Compile Include="Inheritance.fs" /> + <Compile Include="InheritanceAlternative.fs" /> + <Compile Include="InlineFunctions.fs" /> + <Compile Include="Interfaces.fs" /> + <Compile Include="Literals.fs" /> + <Compile Include="Methods.fs" /> + <Compile Include="Namespaces.fs" /> + <Compile Include="NestedModules.fs" /> + <Compile Include="NestedTypes.fs" /> + <Compile Include="OperatorGlobalLevel.fs" /> + <Compile Include="OperatorsOverloading.fs" /> + <Compile Include="PatternMatchingExamples.fs" /> + <Compile Include="Properties.fs" /> + <Compile Include="Records.fs" /> + <Compile Include="ReferenceCells.fs" /> + <Compile Include="Structures.fs" /> + <Compile Include="TypeExtensions.fs" /> + <Compile Include="UnitsOfMeasure.fs" /> + <Compile Include="Vector.fs" /> + <Compile Include="Library1.fs" /> + </ItemGroup> + <ItemGroup> + <Reference Include="mscorlib" /> + <Reference Include="FSharp.Core"> + <Name>FSharp.Core</Name> + <AssemblyName>FSharp.Core.dll</AssemblyName> + <HintPath>$(MSBuildProgramFiles32)\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\$(TargetFSharpCoreVersion)\FSharp.Core.dll</HintPath> + </Reference> + <Reference Include="System" /> + <Reference Include="System.Core" /> + <Reference Include="System.Numerics" /> + <Reference Include="System.ValueTuple"> + <HintPath>..\packages\System.ValueTuple.4.3.1\lib\netstandard1.0\System.ValueTuple.dll</HintPath> + </Reference> + </ItemGroup> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project>
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.FSharp/packages.config b/mdoc/mdoc.Test/mdoc.Test.FSharp/packages.config new file mode 100644 index 00000000..9958f16f --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.FSharp/packages.config @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="utf-8"?> +<packages> + <package id="System.ValueTuple" version="4.3.1" targetFramework="net461" /> +</packages>
\ No newline at end of file diff --git a/mdoc/mdoc.Test/mdoc.Test.csproj b/mdoc/mdoc.Test/mdoc.Test.csproj index 83276da2..f15adf7a 100644 --- a/mdoc/mdoc.Test/mdoc.Test.csproj +++ b/mdoc/mdoc.Test/mdoc.Test.csproj @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -25,11 +25,12 @@ <WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
+ <Reference Include="FSharp.Core, Version=4.4.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="System" />
<Reference Include="nunit.framework">
<HintPath>..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
</Reference>
- <Reference Include="Mono.Cecil, Version=0.10.0.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e, processorArchitecture=MSIL">
+ <Reference Include="Mono.Cecil, Version=0.10.0.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e, processorArchitecture=MSIL">
<HintPath>..\..\packages\Mono.Cecil.0.10.0-beta5\lib\net40\Mono.Cecil.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Mdb, Version=0.10.0.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e, processorArchitecture=MSIL">
@@ -43,7 +44,11 @@ </Reference>
</ItemGroup>
<ItemGroup>
+ <Compile Include="BasicFormatterTests.cs" />
+ <Compile Include="FSharp\BasicFSharpFormatterTests.cs" />
<Compile Include="FormatterTests.cs" />
+ <Compile Include="FSharp\FSharpFormatterTests.cs" />
+ <Compile Include="FSharp\FSharpUsageFormatterTests.cs" />
<Compile Include="SampleClasses\TestClass.cs" />
<Compile Include="SampleClasses\TestPrivateClass.cs" />
<Compile Include="SampleClasses\TestClassTwo.cs" />
@@ -64,10 +69,12 @@ <Project>{6E644802-B579-4037-9809-9CF4C7172C9D}</Project>
<Name>monodoc</Name>
</ProjectReference>
+ <ProjectReference Include="mdoc.Test.FSharp\mdoc.Test.FSharp.fsproj">
+ <Project>{979f9f80-12fe-4236-9e93-6d554ab13701}</Project>
+ <Name>mdoc.Test.FSharp</Name>
+ </ProjectReference>
</ItemGroup>
- <ItemGroup>
- <Folder Include="SampleClasses\" />
- </ItemGroup>
+ <ItemGroup />
<ItemGroup>
<Content Include="cppcli\Debug\cppcli.dll">
<Link>SampleClasses\cppcli.dll</Link>
diff --git a/mdoc/mdoc.csproj b/mdoc/mdoc.csproj index 84c1fd9f..21ca3072 100644 --- a/mdoc/mdoc.csproj +++ b/mdoc/mdoc.csproj @@ -52,6 +52,10 @@ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="Mono.Documentation\Updater\Formatters\ApplePlatformEnumFormatter.cs" />
+ <Compile Include="Mono.Documentation\Updater\Formatters\FSharpFormatter.cs" />
+ <Compile Include="Mono.Documentation\Updater\Formatters\FSharpFullMemberFormatter.cs" />
+ <Compile Include="Mono.Documentation\Updater\Formatters\FSharpMemberFormatter.cs" />
+ <Compile Include="Mono.Documentation\Updater\Formatters\FSharpUsageFormatter.cs" />
<Compile Include="Mono.Documentation\Updater\Formatters\StandardFlagsEnumFormatter.cs" />
<Compile Include="Mono.Documentation\Updater\Formatters\DefaultAttributeValueFormatter.cs" />
<Compile Include="Mono.Documentation\Updater\Formatters\AttributeValueFormatter.cs" />
|