Upgraded to Sandcastle June 2010 release (changeset 54478).

9 files changed, 465 insertions, 396 deletions

diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs
index 56c6316..98794c4 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs
@@ -789,6 +789,7 @@ namespace Microsoft.Ddue.Tools {
 		}
 
 		private void WriteParameters (XPathNodeIterator parameters, bool multiline, SyntaxWriter writer) {
+            bool isVarargs = (bool)parameters.Current.Evaluate(apiIsVarargsExpression);
 
 			while (parameters.MoveNext()) {
 				XPathNavigator parameter = parameters.Current;
@@ -815,9 +816,16 @@ namespace Microsoft.Ddue.Tools {
 				writer.WriteString(" ");
 				writer.WriteParameter(name);
 
-				if (parameters.CurrentPosition < parameters.Count) writer.WriteString(", ");
+				if (parameters.CurrentPosition < parameters.Count || isVarargs) writer.WriteString(", ");
 				if (multiline) writer.WriteLine();
 			}
+            if (isVarargs)
+            {
+                if (multiline) writer.WriteString("\t");
+                writer.WriteString("...");
+                if (multiline) writer.WriteLine();
+            }
+
 
 		}
 
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs
index 3b5922d..26ddcb3 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs
@@ -153,6 +153,7 @@ namespace Microsoft.Ddue.Tools {
 
         // normal method: done
 		public override void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) {
+            if (IsUnsupportedVarargs(reflection, writer)) return;
 
 			string name = (string) reflection.Evaluate(apiNameExpression);
 
@@ -185,91 +186,100 @@ namespace Microsoft.Ddue.Tools {
 		public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
 			string name = (string) reflection.Evaluate(apiNameExpression);
 
-			string identifier;
-			switch (name) {
-				// unary math operators
-				case "UnaryPlus":
-					identifier = "+";
-				break;
-				case "UnaryNegation":
-					identifier = "-";
-				break;
-				case "Increment":
-					identifier = "++";
-				break;
-				case "Decrement":
-					identifier = "--";
-				break;
-				// unary logical operators
-				case "LogicalNot":
-					identifier = "!";
-				break;
-				case "True":
-					identifier = "true";
-				break;
-				case "False":
-					identifier = "false";
-				break;
-				// binary comparison operators
-				case "Equality":
-					identifier = "==";
-				break;
-				case "Inequality":
-					identifier = "!=";
-				break;
-				case "LessThan":
-					identifier = "<";
-				break;
-				case "GreaterThan":
-					identifier = ">";
-				break;
-				case "LessThanOrEqual":
-					identifier = "<=";
-				break;
-				case "GreaterThanOrEqual":
-					identifier = ">=";
-				break;	
-				// binary math operators
-				case "Addition":
-					identifier = "+";
-				break;
-				case "Subtraction":
-					identifier = "-";
-				break;
-				case "Multiply":
-					identifier = "*";
-				break;
-				case "Division":
-					identifier = "/";
-				break;
-				case "Modulus":
-					identifier = "%";
-				break;
-				// binary logical operators
-				case "BitwiseAnd":
-					identifier = "&";
-				break;
-				case "BitwiseOr":
-					identifier = "|";
-				break;
-				case "ExclusiveOr":
-					identifier = "^";
-				break;
-				// bit-array operators
-				case "OnesComplement":
-					identifier = "~";
-				break;
-				case "LeftShift":
-					identifier = "<<";
-				break;
-				case "RightShift":
-					identifier = ">>";
-				break;
-				// unrecognized operator
-				default:
-					identifier = null;
-				break;
-			}
+            string identifier = null;
+            bool evalulate = (bool)reflection.Evaluate(apiIsUdtReturnExpression);
+
+            if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
+            {
+                switch (name)
+                {
+                    // unary math operators
+                    case "UnaryPlus":
+                        identifier = "+";
+                        break;
+                    case "UnaryNegation":
+                        identifier = "-";
+                        break;
+                    case "Increment":
+                        identifier = "++";
+                        break;
+                    case "Decrement":
+                        identifier = "--";
+                        break;
+                    // unary logical operators
+                    case "LogicalNot":
+                        identifier = "!";
+                        break;
+                    case "True":
+                        identifier = "true";
+                        break;
+                    case "False":
+                        identifier = "false";
+                        break;
+                    // binary comparison operators
+                    case "Equality":
+                        identifier = "==";
+                        break;
+                    case "Inequality":
+                        identifier = "!=";
+                        break;
+                    case "LessThan":
+                        identifier = "<";
+                        break;
+                    case "GreaterThan":
+                        identifier = ">";
+                        break;
+                    case "LessThanOrEqual":
+                        identifier = "<=";
+                        break;
+                    case "GreaterThanOrEqual":
+                        identifier = ">=";
+                        break;
+                    // binary math operators
+                    case "Addition":
+                        identifier = "+";
+                        break;
+                    case "Subtraction":
+                        identifier = "-";
+                        break;
+                    case "Multiply":
+                        identifier = "*";
+                        break;
+                    case "Division":
+                        identifier = "/";
+                        break;
+                    case "Modulus":
+                        identifier = "%";
+                        break;
+                    // binary logical operators
+                    case "BitwiseAnd":
+                        identifier = "&";
+                        break;
+                    case "BitwiseOr":
+                        identifier = "|";
+                        break;
+                    case "ExclusiveOr":
+                        identifier = "^";
+                        break;
+                    // bit-array operators
+                    case "OnesComplement":
+                        identifier = "~";
+                        break;
+                    case "LeftShift":
+                        identifier = "<<";
+                        break;
+                    case "RightShift":
+                        identifier = ">>";
+                        break;
+                    case "Assign":
+                        identifier = "=";
+                        break;
+                    // unrecognized operator
+                    default:
+                        identifier = null;
+                        break;
+                }
+            }
 			if (identifier == null) {
 				writer.WriteMessage("UnsupportedOperator_" + Language);
 			} else {
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/FSharpDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/FSharpDeclarationSyntax.cs
index 7f10807..5b173e9 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/FSharpDeclarationSyntax.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/FSharpDeclarationSyntax.cs
@@ -111,6 +111,7 @@ namespace Microsoft.Ddue.Tools
 
         public override void WriteNormalMethodSyntax(XPathNavigator reflection, SyntaxWriter writer)
         {
+            if (IsUnsupportedVarargs(reflection, writer)) return;
 
             string name = (string)reflection.Evaluate(apiNameExpression);
             bool isOverride = (bool)reflection.Evaluate(apiIsOverrideExpression);
@@ -164,94 +165,100 @@ namespace Microsoft.Ddue.Tools
         public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
         {
             string name = (string)reflection.Evaluate(apiNameExpression);
-            string identifier;
+            string identifier = null;
 
             bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
 
-            switch (name)
+            if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
             {
-                // unary math operators
-                case "UnaryPlus":
-                    identifier = "+";
-                    break;
-                case "UnaryNegation":
-                    identifier = "-";
-                    break;
-                case "Increment":
-                    identifier = "++";
-                    break;
-                case "Decrement":
-                    identifier = "--";
-                    break;
-                // unary logical operators
-                case "LogicalNot":
-                    identifier = "not";
-                    break;
-                case "True":
-                    identifier = "true";
-                    break;
-                case "False":
-                    identifier = "false";
-                    break;
-                // binary comparison operators
-                case "Equality":
-                    identifier = "=";
-                    break;
-                case "Inequality":
-                    identifier = "<>";
-                    break;
-                case "LessThan":
-                    identifier = "<";
-                    break;
-                case "GreaterThan":
-                    identifier = ">";
-                    break;
-                case "LessThanOrEqual":
-                    identifier = "<=";
-                    break;
-                case "GreaterThanOrEqual":
-                    identifier = ">=";
-                    break;
-                // binary math operators
-                case "Addition":
-                    identifier = "+";
-                    break;
-                case "Subtraction":
-                    identifier = "-";
-                    break;
-                case "Multiply":
-                    identifier = "*";
-                    break;
-                case "Division":
-                    identifier = "/";
-                    break;
-                case "Modulus":
-                    identifier = "%";
-                    break;
-                // binary logical operators
-                case "BitwiseAnd":
-                    identifier = "&&&";
-                    break;
-                case "BitwiseOr":
-                    identifier = "|||";
-                    break;
-                case "ExclusiveOr":
-                    identifier = "^^^";
-                    break;
-                // bit-array operators
-                case "OnesComplement":
-                   identifier = null; // No F# equiv.
-                   break;
-                case "LeftShift":
-                    identifier = "<<<";
-                    break;
-                case "RightShift":
-                    identifier = ">>>";
-                    break;
-                // unrecognized operator
-                default:
-                    identifier = null;
-                    break;
+                switch (name)
+                {
+                    // unary math operators
+                    case "UnaryPlus":
+                        identifier = "+";
+                        break;
+                    case "UnaryNegation":
+                        identifier = "-";
+                        break;
+                    case "Increment":
+                        identifier = "++";
+                        break;
+                    case "Decrement":
+                        identifier = "--";
+                        break;
+                    // unary logical operators
+                    case "LogicalNot":
+                        identifier = "not";
+                        break;
+                    case "True":
+                        identifier = "true";
+                        break;
+                    case "False":
+                        identifier = "false";
+                        break;
+                    // binary comparison operators
+                    case "Equality":
+                        identifier = "=";
+                        break;
+                    case "Inequality":
+                        identifier = "<>";
+                        break;
+                    case "LessThan":
+                        identifier = "<";
+                        break;
+                    case "GreaterThan":
+                        identifier = ">";
+                        break;
+                    case "LessThanOrEqual":
+                        identifier = "<=";
+                        break;
+                    case "GreaterThanOrEqual":
+                        identifier = ">=";
+                        break;
+                    // binary math operators
+                    case "Addition":
+                        identifier = "+";
+                        break;
+                    case "Subtraction":
+                        identifier = "-";
+                        break;
+                    case "Multiply":
+                        identifier = "*";
+                        break;
+                    case "Division":
+                        identifier = "/";
+                        break;
+                    case "Modulus":
+                        identifier = "%";
+                        break;
+                    // binary logical operators
+                    case "BitwiseAnd":
+                        identifier = "&&&";
+                        break;
+                    case "BitwiseOr":
+                        identifier = "|||";
+                        break;
+                    case "ExclusiveOr":
+                        identifier = "^^^";
+                        break;
+                    // bit-array operators
+                    case "OnesComplement":
+                        identifier = null; // No F# equiv.
+                        break;
+                    case "LeftShift":
+                        identifier = "<<<";
+                        break;
+                    case "RightShift":
+                        identifier = ">>>";
+                        break;
+                    case "Assign":
+                        identifier = "=";
+                        break;
+                    // unrecognized operator
+                    default:
+                        identifier = null;
+                        break;
+                }
             }
             if (identifier == null)
             {
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/GlobalSuppressions.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/GlobalSuppressions.cs
index e8a0676..0bf635c 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/GlobalSuppressions.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/GlobalSuppressions.cs
@@ -299,3 +299,9 @@
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "Microsoft.Ddue.Tools.VisualBasicUsageSyntaxGenerator.#WriteGenericTemplates(System.Xml.XPath.XPathNavigator,Microsoft.Ddue.Tools.SyntaxWriter)")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Scope = "member", Target = "Microsoft.Ddue.Tools.VisualBasicUsageSyntaxGenerator.#WriteGenericTemplates(System.Xml.XPath.XPathNavigator,Microsoft.Ddue.Tools.SyntaxWriter,System.Boolean)")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Scope = "member", Target = "Microsoft.Ddue.Tools.JScriptDeclarationSyntaxGenerator.#WriteVisibility(System.String,Microsoft.Ddue.Tools.SyntaxWriter)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "evalulate", Scope = "member", Target = "Microsoft.Ddue.Tools.CSharpDeclarationSyntaxGenerator.#WriteOperatorSyntax(System.Xml.XPath.XPathNavigator,Microsoft.Ddue.Tools.SyntaxWriter)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible", Scope = "member", Target = "Microsoft.Ddue.Tools.SyntaxGeneratorTemplate.#apiIsUdtReturnExpression")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Varargs", Scope = "member", Target = "Microsoft.Ddue.Tools.SyntaxGeneratorTemplate.#apiIsVarargsExpression")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible", Scope = "member", Target = "Microsoft.Ddue.Tools.SyntaxGeneratorTemplate.#apiIsVarargsExpression")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Varargs", Scope = "member", Target = "Microsoft.Ddue.Tools.SyntaxGeneratorTemplate.#IsUnsupportedVarargs(System.Xml.XPath.XPathNavigator,Microsoft.Ddue.Tools.SyntaxWriter)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1307:SpecifyStringComparison", MessageId = "System.String.StartsWith(System.String)", Scope = "member", Target = "Microsoft.Ddue.Tools.SyntaxGeneratorTemplate.#WriteMethodSyntax(System.Xml.XPath.XPathNavigator,Microsoft.Ddue.Tools.SyntaxWriter)")]
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs
index 27ac11d..35c1cc6 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs
@@ -101,6 +101,7 @@ namespace Microsoft.Ddue.Tools {
             if (IsUnsupportedUnsafe(reflection, writer)) return;
             if (IsUnsupportedGeneric(reflection, writer)) return;
             if (IsUnsupportedExplicit(reflection, writer)) return;
+            if (IsUnsupportedVarargs(reflection, writer)) return;
 
             string name = (string)reflection.Evaluate(apiNameExpression);
             XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs
index b425318..b1dfc12 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs
@@ -38,5 +38,5 @@ using System.Runtime.InteropServices;
 //
 // You can specify all the values or you can default the Revision and Build Numbers 
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("2.5.10626.00")]
-[assembly: AssemblyFileVersion("2.5.10626.00")]
+[assembly: AssemblyVersion("2.6.10621.1")]
+[assembly: AssemblyFileVersion("2.6.10621.1")]
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs
index 8f9f2c9..30255dd 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs
@@ -88,6 +88,7 @@ namespace Microsoft.Ddue.Tools {
 		protected static XPathExpression apiIsAbstractProcedureExpression = XPathExpression.Compile("boolean(proceduredata[@abstract='true'])");
 		protected static XPathExpression apiIsVirtualExpression = XPathExpression.Compile("boolean(proceduredata[@virtual='true'])");
 		protected static XPathExpression apiIsFinalExpression = XPathExpression.Compile("boolean(proceduredata[@final='true'])");
+        protected static XPathExpression apiIsVarargsExpression = XPathExpression.Compile("boolean(proceduredata[@varargs='true'])");
 		protected static XPathExpression apiOverridesMemberExpression = XPathExpression.Compile("string(proceduredata/@overrides/member)");
 		protected static XPathExpression apiIsExplicitImplementationExpression = XPathExpression.Compile("boolean(memberdata/@visibility='private' and proceduredata/@virtual='true' and boolean(implements/member))");
 		protected static XPathExpression apiImplementedMembersExpression = XPathExpression.Compile("implements/member");
@@ -98,6 +99,8 @@ namespace Microsoft.Ddue.Tools {
 		protected static XPathExpression apiIsWritePropertyExpression = XPathExpression.Compile("boolean(propertydata/@set='true')");
         protected static XPathExpression apiGetVisibilityExpression = XPathExpression.Compile("string(propertydata/@get-visibility)");
         protected static XPathExpression apiSetVisibilityExpression = XPathExpression.Compile("string(propertydata/@set-visibility)");
+        // return data
+        protected static XPathExpression apiIsUdtReturnExpression = XPathExpression.Compile("boolean(returns/type[@api='T:System.Void']/requiredModifier/type[@api='T:System.Runtime.CompilerServices.IsUdtReturn'])");
 
 		// event data
 		protected static XPathExpression apiHandlerOfEventExpression = XPathExpression.Compile("eventhandler/*[1]");
@@ -262,6 +265,11 @@ namespace Microsoft.Ddue.Tools {
                         WriteOperatorSyntax(reflection, writer);
                     }
                 }
+                // Write out let properties (no .Net equivalent) as methods
+                if(name.StartsWith("let_"))
+                {
+                    WriteNormalMethodSyntax(reflection, writer);
+                }
             } else {
                 WriteNormalMethodSyntax(reflection, writer);
             }
@@ -309,6 +317,16 @@ namespace Microsoft.Ddue.Tools {
             }
         }
 
+        protected virtual bool IsUnsupportedVarargs(XPathNavigator reflection, SyntaxWriter writer)
+        {
+            bool isVarargs = (bool) reflection.Evaluate(apiIsVarargsExpression);
+            
+            if(isVarargs)
+                writer.WriteMessage("UnsupportedVarargs_" + Language);
+
+            return (isVarargs);
+        }
+
         protected virtual bool IsUnsupportedUnsafe(XPathNavigator reflection, SyntaxWriter writer)
         {
 			bool isUnsafe = (bool) reflection.Evaluate(apiIsUnsafeExpression);
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs
index e90ab1a..959aa14 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs
@@ -161,6 +161,7 @@ namespace Microsoft.Ddue.Tools {
 
 
 		public override void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) {
+            if (IsUnsupportedVarargs(reflection, writer)) return;
 
 			string name = (string) reflection.Evaluate(apiNameExpression);
 			XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
@@ -211,106 +212,113 @@ namespace Microsoft.Ddue.Tools {
 			string name = (string) reflection.Evaluate(apiNameExpression);
 			XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
 
-			string identifier;
-			switch (name) {
-				// unary math operators
-				case "UnaryPlus":
-					identifier = "+";
-				break;
-				case "UnaryNegation":
-					identifier = "-";
-				break;
-				case "Increment":
-					identifier = "++";
-				break;
-				case "Decrement":
-					identifier = "--";
-				break;
-				// unary logical operators
-				case "LogicalNot":
-					identifier = "Not";
-				break;
-				case "True":
-					identifier = "IsTrue";
-				break;
-				case "False":
-					identifier = "IsFalse";
-				break;
-				// binary comparison operators
-				case "Equality":
-					identifier = "=";
-				break;
-				case "Inequality":
-					identifier = "<>";
-				break;
-				case "LessThan":
-					identifier = "<";
-				break;
-				case "GreaterThan":
-					identifier = ">";
-				break;
-				case "LessThanOrEqual":
-					identifier = "<=";
-				break;
-				case "GreaterThanOrEqual":
-					identifier = ">=";
-				break;	
-				// binary math operators
-				case "Addition":
-					identifier = "+";
-				break;
-				case "Subtraction":
-					identifier = "-";
-				break;
-				case "Multiply":
-					identifier = "*";
-				break;
-				case "Division":
-					identifier = "/";
-				break;
-				case "Exponent":
-					identifier = "^";
-				break;
-				case "Modulus":
-					identifier = "Mod";
-				break;
-				case "IntegerDivision":
-					identifier = @"\";
-				break;
-				// binary logical operators
-				case "BitwiseAnd":
-					identifier = "And";
-				break;
-				case "BitwiseOr":
-					identifier = "Or";
-				break;
-				case "ExclusiveOr":
-					identifier = "Xor";
-				break;
-				// bit-array operators
-				case "OnesComplement":
-					identifier = "~";
-				break;
-				case "LeftShift":
-					identifier = "<<";
-				break;
-				case "RightShift":
-					identifier = ">>";
-				break;
-				// concatenation
-				case "Concatenate":
-					identifier = "&";
-				break;
-				// casting operators
-				case "Implicit":
-				case "Explicit":
-					identifier = "CType";
-				break;
-				// didn't recognize an operator
-				default:
-					identifier = null;
-				break;
-			}
+			string identifier = null;
+            if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
+            {
+                switch (name)
+                {
+                    // unary math operators
+                    case "UnaryPlus":
+                        identifier = "+";
+                        break;
+                    case "UnaryNegation":
+                        identifier = "-";
+                        break;
+                    case "Increment":
+                        identifier = "++";
+                        break;
+                    case "Decrement":
+                        identifier = "--";
+                        break;
+                    // unary logical operators
+                    case "LogicalNot":
+                        identifier = "Not";
+                        break;
+                    case "True":
+                        identifier = "IsTrue";
+                        break;
+                    case "False":
+                        identifier = "IsFalse";
+                        break;
+                    // binary comparison operators
+                    case "Equality":
+                        identifier = "=";
+                        break;
+                    case "Inequality":
+                        identifier = "<>";
+                        break;
+                    case "LessThan":
+                        identifier = "<";
+                        break;
+                    case "GreaterThan":
+                        identifier = ">";
+                        break;
+                    case "LessThanOrEqual":
+                        identifier = "<=";
+                        break;
+                    case "GreaterThanOrEqual":
+                        identifier = ">=";
+                        break;
+                    // binary math operators
+                    case "Addition":
+                        identifier = "+";
+                        break;
+                    case "Subtraction":
+                        identifier = "-";
+                        break;
+                    case "Multiply":
+                        identifier = "*";
+                        break;
+                    case "Division":
+                        identifier = "/";
+                        break;
+                    case "Exponent":
+                        identifier = "^";
+                        break;
+                    case "Modulus":
+                        identifier = "Mod";
+                        break;
+                    case "IntegerDivision":
+                        identifier = @"\";
+                        break;
+                    // binary logical operators
+                    case "BitwiseAnd":
+                        identifier = "And";
+                        break;
+                    case "BitwiseOr":
+                        identifier = "Or";
+                        break;
+                    case "ExclusiveOr":
+                        identifier = "Xor";
+                        break;
+                    // bit-array operators
+                    case "OnesComplement":
+                        identifier = "~";
+                        break;
+                    case "LeftShift":
+                        identifier = "<<";
+                        break;
+                    case "RightShift":
+                        identifier = ">>";
+                        break;
+                    // concatenation
+                    case "Concatenate":
+                        identifier = "&";
+                        break;
+                    // casting operators
+                    case "Implicit":
+                    case "Explicit":
+                        identifier = "CType";
+                        break;
+                    case "Assign":
+                        identifier = "=";
+                        break;
+                    // didn't recognize an operator
+                    default:
+                        identifier = null;
+                        break;
+                }
+            }
 			if (identifier == null) {
 				writer.WriteMessage("UnsupportedOperator_" + Language);
 				return;
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs
index a32faf2..702e627 100644
--- a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs
+++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs
@@ -249,6 +249,7 @@ namespace Microsoft.Ddue.Tools {
 
         public override void WriteMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) {
             if (IsUnsupportedUnsafe(reflection, writer)) return;
+            if (IsUnsupportedVarargs(reflection, writer)) return;
             base.WriteMethodSyntax(reflection, writer);
         }
 
@@ -353,131 +354,141 @@ namespace Microsoft.Ddue.Tools {
             XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
 
             // Determine operator identifier and type
-            string identifier;
-            int type;
-            switch (name) {
-                // unary math operators
-                case "UnaryPlus":
-                    identifier = "+";
-                    type = -1;
-                    break;
-                case "UnaryNegation":
-                    identifier = "-";
-                    type = -1;
-                    break;
-                case "Increment":
-                    identifier = "++";
-                    type = +1;
-                    break;
-                case "Decrement":
-                    identifier = "--";
-                    type = +1;
-                    break;
-                // unary logical operators
-                case "LogicalNot":
-                    identifier = "Not";
-                    type = -1;
-                    break;
-                case "True":
-                    identifier = "IsTrue";
-                    type = -1;
-                    break;
-                case "False":
-                    identifier = "IsFalse";
-                    type = -1;
-                    break;
-                // binary comparison operators
-                case "Equality":
-                    identifier = "=";
-                    type = 2;
-                    break;
-                case "Inequality":
-                    identifier = "<>";
-                    type = 2;
-                    break;
-                case "LessThan":
-                    identifier = "<";
-                    type = 2;
-                    break;
-                case "GreaterThan":
-                    identifier = ">";
-                    type = 2;
-                    break;
-                case "LessThanOrEqual":
-                    identifier = "<=";
-                    type = 2;
-                    break;
-                case "GreaterThanOrEqual":
-                    identifier = ">=";
-                    type = 2;
-                    break;
-                // binary math operators
-                case "Addition":
-                    identifier = "+";
-                    type = 2;
-                    break;
-                case "Subtraction":
-                    identifier = "-";
-                    type = 2;
-                    break;
-                case "Multiply":
-                    identifier = "*";
-                    type = 2;
-                    break;
-                case "Division":
-                    identifier = "/";
-                    type = 2;
-                    break;
-                case "Exponent":
-                    identifier = "^";
-                    type = 2;
-                    break;
-                case "Modulus":
-                    identifier = "Mod";
-                    type = 2;
-                    break;
-                case "IntegerDivision":
-                    identifier = @"\";
-                    type = 2;
-                    break;
-                // binary logical operators
-                case "BitwiseAnd":
-                    identifier = "And";
-                    type = 2;
-                    break;
-                case "BitwiseOr":
-                    identifier = "Or";
-                    type = 2;
-                    break;
-                case "ExclusiveOr":
-                    identifier = "Xor";
-                    type = 2;
-                    break;
-                // bit-array operators
-                case "OnesComplement":
-                    identifier = "~";
-                    type = -1;
-                    break;
-                case "LeftShift":
-                    identifier = "<<";
-                    type = 2;
-                    break;
-                case "RightShift":
-                    identifier = ">>";
-                    type = 2;
-                    break;
-                // concatenation
-                case "Concatenate":
-                    identifier = "&";
-                    type = 2;
-                    break;
-                // didn't recognize an operator
-                default:
-                    identifier = null;
-                    type = 0;
-                break;
-            }
+            string identifier = null;
+            int type = 0;
 
+            if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
+            {
+                switch (name)
+                {
+                    // unary math operators
+                    case "UnaryPlus":
+                        identifier = "+";
+                        type = -1;
+                        break;
+                    case "UnaryNegation":
+                        identifier = "-";
+                        type = -1;
+                        break;
+                    case "Increment":
+                        identifier = "++";
+                        type = +1;
+                        break;
+                    case "Decrement":
+                        identifier = "--";
+                        type = +1;
+                        break;
+                    // unary logical operators
+                    case "LogicalNot":
+                        identifier = "Not";
+                        type = -1;
+                        break;
+                    case "True":
+                        identifier = "IsTrue";
+                        type = -1;
+                        break;
+                    case "False":
+                        identifier = "IsFalse";
+                        type = -1;
+                        break;
+                    // binary comparison operators
+                    case "Equality":
+                        identifier = "=";
+                        type = 2;
+                        break;
+                    case "Inequality":
+                        identifier = "<>";
+                        type = 2;
+                        break;
+                    case "LessThan":
+                        identifier = "<";
+                        type = 2;
+                        break;
+                    case "GreaterThan":
+                        identifier = ">";
+                        type = 2;
+                        break;
+                    case "LessThanOrEqual":
+                        identifier = "<=";
+                        type = 2;
+                        break;
+                    case "GreaterThanOrEqual":
+                        identifier = ">=";
+                        type = 2;
+                        break;
+                    // binary math operators
+                    case "Addition":
+                        identifier = "+";
+                        type = 2;
+                        break;
+                    case "Subtraction":
+                        identifier = "-";
+                        type = 2;
+                        break;
+                    case "Multiply":
+                        identifier = "*";
+                        type = 2;
+                        break;
+                    case "Division":
+                        identifier = "/";
+                        type = 2;
+                        break;
+                    case "Exponent":
+                        identifier = "^";
+                        type = 2;
+                        break;
+                    case "Modulus":
+                        identifier = "Mod";
+                        type = 2;
+                        break;
+                    case "IntegerDivision":
+                        identifier = @"\";
+                        type = 2;
+                        break;
+                    // binary logical operators
+                    case "BitwiseAnd":
+                        identifier = "And";
+                        type = 2;
+                        break;
+                    case "BitwiseOr":
+                        identifier = "Or";
+                        type = 2;
+                        break;
+                    case "ExclusiveOr":
+                        identifier = "Xor";
+                        type = 2;
+                        break;
+                    // bit-array operators
+                    case "OnesComplement":
+                        identifier = "~";
+                        type = -1;
+                        break;
+                    case "LeftShift":
+                        identifier = "<<";
+                        type = 2;
+                        break;
+                    case "RightShift":
+                        identifier = ">>";
+                        type = 2;
+                        break;
+                    // concatenation
+                    case "Concatenate":
+                        identifier = "&";
+                        type = 2;
+                        break;
+                    case "Assign":
+                        identifier = "=";
+                        type = 2;
+                        break;
+
+
+                    // didn't recognize an operator
+                    default:
+                        identifier = null;
+                        type = 0;
+                        break;
+                }
+            }
             if (identifier == null) {
                 writer.WriteMessage("UnsupportedOperator_" + Language);
             } else {