I split out C# 'await' expressions into their own SyntaxNode type consistent...

I split out C# 'await' expressions into their own SyntaxNode type consistent with their representation in the VB syntax tree. Previously 'await' expressions were represented as a kind of PrefixUnaryExpressionSyntax. (changeset 1348213)

Src/Compilers/CSharp/Portable/Binder/Binder_Await.cs

@@ -13,9 +13,9 @@ namespace Microsoft.CodeAnalysis.CSharp
     /// </summary>
     internal partial class Binder
     {
-        private BoundExpression BindAwait(PrefixUnaryExpressionSyntax node, DiagnosticBag diagnostics)
+        private BoundExpression BindAwait(AwaitExpressionSyntax node, DiagnosticBag diagnostics)
         {
-            BoundExpression expression = BindValue(node.Operand, diagnostics, BindValueKind.RValue);
+            BoundExpression expression = BindValue(node.Expression, diagnostics, BindValueKind.RValue);
 
             return BindAwait(expression, node, diagnostics);
         }

Src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

@@ -560,7 +560,7 @@ private BoundExpression BindExpressionInternal(ExpressionSyntax node, Diagnostic
                     return BindRefValue((RefValueExpressionSyntax)node, diagnostics);
 
                 case SyntaxKind.AwaitExpression:
-                    return BindAwait((PrefixUnaryExpressionSyntax)node, diagnostics);
+                    return BindAwait((AwaitExpressionSyntax)node, diagnostics);
 
                 case SyntaxKind.OmittedArraySizeExpression:
                 case SyntaxKind.OmittedTypeArgument:

Src/Compilers/CSharp/Portable/CSharpExtensions.cs

@@ -689,7 +689,7 @@ public static ForEachStatementInfo GetForEachStatementInfo(this SemanticModel se
             }
         }
 
-        public static AwaitExpressionInfo GetAwaitExpressionInfo(this SemanticModel semanticModel, PrefixUnaryExpressionSyntax awaitExpression)
+        public static AwaitExpressionInfo GetAwaitExpressionInfo(this SemanticModel semanticModel, AwaitExpressionSyntax awaitExpression)
         {
             var csmodel = semanticModel as CSharpSemanticModel;
             if (csmodel != null)

Src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -4101,7 +4101,7 @@ private static ImmutableArray<Symbol> CreateReducedExtensionMethodIfPossible(Bou
         /// Gets await expression info.
         /// </summary>
         /// <param name="node">The node.</param>
-        public abstract AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node);
+        public abstract AwaitExpressionInfo GetAwaitExpressionInfo(AwaitExpressionSyntax node);
 
         /// <summary>
         /// If the given node is within a preprocessing directive, gets the preprocessing symbol info for it.

Src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs

@@ -625,7 +625,7 @@ public override IRangeVariableSymbol GetDeclaredSymbol(QueryContinuationSyntax n
             return bound == null ? null : bound.DefinedSymbol;
         }
 
-        public override AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node)
+        public override AwaitExpressionInfo GetAwaitExpressionInfo(AwaitExpressionSyntax node)
         {
             if (node.Kind != SyntaxKind.AwaitExpression)
             {

Src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs

@@ -2092,7 +2092,7 @@ private Symbol GetDeclaredMemberSymbol(CSharpSyntaxNode declarationSyntax)
             return this.GetDeclaredMember(container, declarationSyntax.Span, name);
         }
 
-        public override AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node)
+        public override AwaitExpressionInfo GetAwaitExpressionInfo(AwaitExpressionSyntax node)
         {
             using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetAwaitExpressionInfo, message: this.SyntaxTree.FilePath))
             {

Src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -8289,7 +8289,7 @@ private ExpressionSyntax ParseSubExpression(uint precedence)
                 var awaitToken = this.EatContextualToken(SyntaxKind.AwaitKeyword);
                 awaitToken = CheckFeatureAvailability(awaitToken, MessageID.IDS_FeatureAsync);
                 var operand = this.ParseSubExpression(newPrecedence);
-                leftOperand = syntaxFactory.PrefixUnaryExpression(opKind, awaitToken, operand);
+                leftOperand = syntaxFactory.AwaitExpression(awaitToken, operand);
             }
             else if (this.IsQueryExpression(mayBeVariableDeclaration: false, mayBeMemberDeclaration: false))
             {

Src/Compilers/CSharp/Portable/Syntax/Syntax.xml

@@ -295,7 +295,6 @@
     <Kind Name="PreDecrementExpression"/>
     <Kind Name="AddressOfExpression"/>
     <Kind Name="PointerIndirectionExpression"/>
-    <Kind Name="AwaitExpression"/>
     <Field Name="OperatorToken" Type="SyntaxToken">
       <Kind Name="PlusToken"/>
       <Kind Name="MinusToken"/>
@@ -305,7 +304,6 @@
       <Kind Name="MinusMinusToken"/>
       <Kind Name="AmpersandToken"/>
       <Kind Name="AsteriskToken"/>
-      <Kind Name="AwaitKeyword"/>
       <PropertyComment>
         <summary>SyntaxToken representing the kind of the operator of the prefix unary expression.</summary>
       </PropertyComment>
@@ -322,6 +320,26 @@
       <summary>Creates an PrefixUnaryExpressionSyntax node.</summary>
     </FactoryComment>
   </Node>
+  <Node Name="AwaitExpressionSyntax" Base="ExpressionSyntax">
+    <Kind Name="AwaitExpression"/>
+    <Field Name="AwaitKeyword" Type="SyntaxToken">
+      <Kind Name="AwaitKeyword"/>
+      <PropertyComment>
+        <summary>SyntaxToken representing the kind "await" keyword.</summary>
+      </PropertyComment>
+    </Field>
+    <Field Name="Expression" Type="ExpressionSyntax">
+      <PropertyComment>
+        <summary>ExpressionSyntax representing the operand of the "await" operator.</summary>
+      </PropertyComment>
+    </Field>
+    <TypeComment>
+      <summary>Class which represents the syntax node for an "await" expression.</summary>
+    </TypeComment>
+    <FactoryComment>
+      <summary>Creates an AwaitExpressionSyntax node.</summary>
+    </FactoryComment>
+  </Node>
   <Node Name="PostfixUnaryExpressionSyntax" Base="ExpressionSyntax">
     <Kind Name="PostIncrementExpression"/>
     <Kind Name="PostDecrementExpression"/>

Src/Compilers/CSharp/Test/Semantic/Semantics/AwaitExpressionTests.cs

@@ -40,34 +40,11 @@ private AwaitExpressionInfo GetAwaitExpressionInfo(string text, params Diagnosti
             var tree = Parse(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));
             var comp = CreateCompilationWithMscorlib45(new SyntaxTree[] { tree }, new MetadataReference[] { SystemRef });
             comp.VerifyDiagnostics(diagnostics);
-            var syntaxNode = (PrefixUnaryExpressionSyntax)tree.FindNodeOrTokenByKind(SyntaxKind.AwaitExpression).AsNode();
+            var syntaxNode = (AwaitExpressionSyntax)tree.FindNodeOrTokenByKind(SyntaxKind.AwaitExpression).AsNode();
             var treeModel = comp.GetSemanticModel(tree);
             return treeModel.GetAwaitExpressionInfo(syntaxNode);
         }
 
-        [Fact]
-        [WorkItem(711413, "DevDiv")]
-        public void TestAwaitInfoWrongSyntaxKind()
-        {
-            var text =
-@"
-class C
-{
-    int Foo(int t)
-    {
-        return + t;
-    }
-}";
-            var tree = Parse(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));
-            var comp = CreateCompilationWithMscorlib45(new SyntaxTree[] { tree }, new MetadataReference[] { SystemRef });
-            comp.VerifyDiagnostics();
-            var syntaxNode = (PrefixUnaryExpressionSyntax)tree.FindNodeOrTokenByKind(SyntaxKind.UnaryPlusExpression).AsNode();
-            var treeModel = comp.GetSemanticModel(tree);
-            Assert.Throws<System.ArgumentException>(() => {
-                var info = treeModel.GetAwaitExpressionInfo(syntaxNode);
-            });
-        }
-
         [Fact]
         [WorkItem(748533, "DevDiv")]
         public void Bug748533()

Src/Compilers/VisualBasic/Portable/Syntax/Syntax.xml

@@ -7603,7 +7603,7 @@ Unify Enum declarations with other block type declarations.
       -  AwaitExpression
       ******************-->
     <node-structure name="AwaitExpressionSyntax" parent="ExpressionSyntax">
-      <description>Represent a Await expression.</description>
+      <description>Represents an Await expression.</description>
       <lm-equiv name="AwaitExpressionNode"></lm-equiv>
       <native-equiv name="AwaitExpression"></native-equiv>
 

Src/Diagnostics/Roslyn/CSharp/Reliability/CSharpDirectlyAwaitingTaskAnalyzer.cs

@@ -26,7 +26,7 @@ protected override SyntaxKind AwaitSyntaxKind
         
         protected override SyntaxNode GetAwaitedExpression(SyntaxNode awaitNode)
         {
-            return ((PrefixUnaryExpressionSyntax)awaitNode).Operand;
+            return ((AwaitExpressionSyntax)awaitNode).Expression;
         }
     }
 }

Src/Workspaces/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs

@@ -1666,6 +1666,13 @@ public static bool IsLabelContext(this SyntaxTree syntaxTree, int position, Canc
                 token.Kind == SyntaxKind.PlusPlusToken ||
                 token.Kind == SyntaxKind.DashDashToken)
 #endif
+            // await |
+            if (token.Parent is AwaitExpressionSyntax)
+            {
+                var awaitExpression = token.Parent as AwaitExpressionSyntax;
+                return awaitExpression.AwaitKeyword == token;
+            }
+
             // Check for binary operators.
             // Note:
             //   - We handle < specially as it can be ambiguous with generics.

Src/Workspaces/CSharp/Extensions/ExpressionSyntaxExtensions.cs

@@ -515,6 +515,11 @@ private static bool CanReplace(ISymbol symbol)
                 }
             }
 
+            if (expression.Parent is AwaitExpressionSyntax)
+            {
+                return true;
+            }
+
             var parentNonExpression = expression.GetAncestors().SkipWhile(n => n is ExpressionSyntax).FirstOrDefault();
             var topExpression = expression;
             while (topExpression.Parent is TypeSyntax)

Src/Workspaces/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs

@@ -214,6 +214,7 @@ private IEnumerable<ITypeSymbol> InferTypesWorker(ExpressionSyntax expression)
                     (ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpression) => InferTypeInParenthesizedLambdaExpression(parenthesizedLambdaExpression),
                     (PostfixUnaryExpressionSyntax postfixUnary) => InferTypeInPostfixUnaryExpression(postfixUnary),
                     (PrefixUnaryExpressionSyntax prefixUnary) => InferTypeInPrefixUnaryExpression(prefixUnary),
+                    (AwaitExpressionSyntax awaitExpression) => InferTypeInAwaitExpression(awaitExpression),
                     (ReturnStatementSyntax returnStatement) => InferTypeForReturnStatement(returnStatement),
                     (SimpleLambdaExpressionSyntax simpleLambdaExpression) => InferTypeInSimpleLambdaExpression(simpleLambdaExpression),
                     (SwitchLabelSyntax switchLabel) => InferTypeInSwitchLabel(switchLabel),
@@ -264,6 +265,7 @@ private IEnumerable<ITypeSymbol> InferTypesWorker(int position)
                     (ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpression) => InferTypeInParenthesizedLambdaExpression(parenthesizedLambdaExpression, token),
                     (PostfixUnaryExpressionSyntax postfixUnary) => InferTypeInPostfixUnaryExpression(postfixUnary, token),
                     (PrefixUnaryExpressionSyntax prefixUnary) => InferTypeInPrefixUnaryExpression(prefixUnary, token),
+                    (AwaitExpressionSyntax awaitExpression) => InferTypeInAwaitExpression(awaitExpression, token),
                     (ReturnStatementSyntax returnStatement) => InferTypeForReturnStatement(returnStatement, token),
                     (SimpleLambdaExpressionSyntax simpleLambdaExpression) => InferTypeInSimpleLambdaExpression(simpleLambdaExpression, token),
                     (SwitchLabelSyntax switchLabel) => InferTypeInSwitchLabel(switchLabel, token),
@@ -1264,25 +1266,6 @@ private IEnumerable<ITypeSymbol> InferTypeInPrefixUnaryExpression(PrefixUnaryExp
 
                 switch (prefixUnaryExpression.CSharpKind())
                 {
-                    case SyntaxKind.AwaitExpression:
-                        // await <expression>
-                        var types = InferTypes(prefixUnaryExpression);
-
-                        var task = this.Compilation.TaskType();
-                        var taskOfT = this.Compilation.TaskOfTType();
-
-                        if (task == null || taskOfT == null)
-                        {
-                            break;
-                        }
-
-                        if (!types.Any())
-                        {
-                            return SpecializedCollections.SingletonEnumerable(task);
-                        }
-
-                        return types.Select(t => t.SpecialType == SpecialType.System_Void ? task : taskOfT.Construct(t));
-
                     case SyntaxKind.PreDecrementExpression:
                     case SyntaxKind.PreIncrementExpression:
                     case SyntaxKind.UnaryPlusExpression:
@@ -1299,6 +1282,30 @@ private IEnumerable<ITypeSymbol> InferTypeInPrefixUnaryExpression(PrefixUnaryExp
                 return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
             }
 
+            private IEnumerable<ITypeSymbol> InferTypeInAwaitExpression(AwaitExpressionSyntax awaitExpression, SyntaxToken? previousToken = null)
+            {
+                // If we have a position, then we must be after the prefix token.
+                Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != awaitExpression.AwaitKeyword);
+
+                // await <expression>
+                var types = InferTypes(awaitExpression);
+
+                var task = this.Compilation.TaskType();
+                var taskOfT = this.Compilation.TaskOfTType();
+
+                if (task == null || taskOfT == null)
+                {
+                    return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
+                }
+
+                if (!types.Any())
+                {
+                    return SpecializedCollections.SingletonEnumerable(task);
+                }
+
+                return types.Select(t => t.SpecialType == SpecialType.System_Void ? task : taskOfT.Construct(t));
+            }
+
             private IEnumerable<ITypeSymbol> InferTypeInYieldStatement(YieldStatementSyntax yieldStatement, SyntaxToken? previousToken = null)
             {
                 // If we are position based, then we have to be after the return keyword

Src/Workspaces/Core/Shared/Extensions/ObjectExtensions.TypeSwitch.cs

@@ -7449,6 +7449,218 @@ internal static partial class ObjectExtensions
                 return default(TResult);
             }
         }
+
+        public static TResult TypeSwitch<TBaseType, TDerivedType1, TDerivedType2, TDerivedType3, TDerivedType4, TDerivedType5, TDerivedType6, TDerivedType7, TDerivedType8, TDerivedType9, TDerivedType10, TDerivedType11, TDerivedType12, TDerivedType13, TDerivedType14, TDerivedType15, TDerivedType16, TDerivedType17, TDerivedType18, TDerivedType19, TDerivedType20, TDerivedType21, TDerivedType22, TDerivedType23, TDerivedType24, TDerivedType25, TDerivedType26, TDerivedType27, TDerivedType28, TDerivedType29, TDerivedType30, TDerivedType31, TDerivedType32, TDerivedType33, TDerivedType34, TDerivedType35, TDerivedType36, TDerivedType37, TDerivedType38, TDerivedType39, TDerivedType40, TResult>(this TBaseType obj, Func<TDerivedType1, TResult> matchFunc1, Func<TDerivedType2, TResult> matchFunc2, Func<TDerivedType3, TResult> matchFunc3, Func<TDerivedType4, TResult> matchFunc4, Func<TDerivedType5, TResult> matchFunc5, Func<TDerivedType6, TResult> matchFunc6, Func<TDerivedType7, TResult> matchFunc7, Func<TDerivedType8, TResult> matchFunc8, Func<TDerivedType9, TResult> matchFunc9, Func<TDerivedType10, TResult> matchFunc10, Func<TDerivedType11, TResult> matchFunc11, Func<TDerivedType12, TResult> matchFunc12, Func<TDerivedType13, TResult> matchFunc13, Func<TDerivedType14, TResult> matchFunc14, Func<TDerivedType15, TResult> matchFunc15, Func<TDerivedType16, TResult> matchFunc16, Func<TDerivedType17, TResult> matchFunc17, Func<TDerivedType18, TResult> matchFunc18, Func<TDerivedType19, TResult> matchFunc19, Func<TDerivedType20, TResult> matchFunc20, Func<TDerivedType21, TResult> matchFunc21, Func<TDerivedType22, TResult> matchFunc22, Func<TDerivedType23, TResult> matchFunc23, Func<TDerivedType24, TResult> matchFunc24, Func<TDerivedType25, TResult> matchFunc25, Func<TDerivedType26, TResult> matchFunc26, Func<TDerivedType27, TResult> matchFunc27, Func<TDerivedType28, TResult> matchFunc28, Func<TDerivedType29, TResult> matchFunc29, Func<TDerivedType30, TResult> matchFunc30, Func<TDerivedType31, TResult> matchFunc31, Func<TDerivedType32, TResult> matchFunc32, Func<TDerivedType33, TResult> matchFunc33, Func<TDerivedType34, TResult> matchFunc34, Func<TDerivedType35, TResult> matchFunc35, Func<TDerivedType36, TResult> matchFunc36, Func<TDerivedType37, TResult> matchFunc37, Func<TDerivedType38, TResult> matchFunc38, Func<TDerivedType39, TResult> matchFunc39, Func<TDerivedType40, TResult> matchFunc40, Func<TBaseType, TResult> defaultFunc = null)
+            where TDerivedType1 : TBaseType
+            where TDerivedType2 : TBaseType
+            where TDerivedType3 : TBaseType
+            where TDerivedType4 : TBaseType
+            where TDerivedType5 : TBaseType
+            where TDerivedType6 : TBaseType
+            where TDerivedType7 : TBaseType
+            where TDerivedType8 : TBaseType
+            where TDerivedType9 : TBaseType
+            where TDerivedType10 : TBaseType
+            where TDerivedType11 : TBaseType
+            where TDerivedType12 : TBaseType
+            where TDerivedType13 : TBaseType
+            where TDerivedType14 : TBaseType
+            where TDerivedType15 : TBaseType
+            where TDerivedType16 : TBaseType
+            where TDerivedType17 : TBaseType
+            where TDerivedType18 : TBaseType
+            where TDerivedType19 : TBaseType
+            where TDerivedType20 : TBaseType
+            where TDerivedType21 : TBaseType
+            where TDerivedType22 : TBaseType
+            where TDerivedType23 : TBaseType
+            where TDerivedType24 : TBaseType
+            where TDerivedType25 : TBaseType
+            where TDerivedType26 : TBaseType
+            where TDerivedType27 : TBaseType
+            where TDerivedType28 : TBaseType
+            where TDerivedType29 : TBaseType
+            where TDerivedType30 : TBaseType
+            where TDerivedType31 : TBaseType
+            where TDerivedType32 : TBaseType
+            where TDerivedType33 : TBaseType
+            where TDerivedType34 : TBaseType
+            where TDerivedType35 : TBaseType
+            where TDerivedType36 : TBaseType
+            where TDerivedType37 : TBaseType
+            where TDerivedType38 : TBaseType
+            where TDerivedType39 : TBaseType
+            where TDerivedType40 : TBaseType
+        {
+            if (obj is TDerivedType1)
+            {
+                return matchFunc1((TDerivedType1)obj);
+            }
+            else if (obj is TDerivedType2)
+            {
+                return matchFunc2((TDerivedType2)obj);
+            }
+            else if (obj is TDerivedType3)
+            {
+                return matchFunc3((TDerivedType3)obj);
+            }
+            else if (obj is TDerivedType4)
+            {
+                return matchFunc4((TDerivedType4)obj);
+            }
+            else if (obj is TDerivedType5)
+            {
+                return matchFunc5((TDerivedType5)obj);
+            }
+            else if (obj is TDerivedType6)
+            {
+                return matchFunc6((TDerivedType6)obj);
+            }
+            else if (obj is TDerivedType7)
+            {
+                return matchFunc7((TDerivedType7)obj);
+            }
+            else if (obj is TDerivedType8)
+            {
+                return matchFunc8((TDerivedType8)obj);
+            }
+            else if (obj is TDerivedType9)
+            {
+                return matchFunc9((TDerivedType9)obj);
+            }
+            else if (obj is TDerivedType10)
+            {
+                return matchFunc10((TDerivedType10)obj);
+            }
+            else if (obj is TDerivedType11)
+            {
+                return matchFunc11((TDerivedType11)obj);
+            }
+            else if (obj is TDerivedType12)
+            {
+                return matchFunc12((TDerivedType12)obj);
+            }
+            else if (obj is TDerivedType13)
+            {
+                return matchFunc13((TDerivedType13)obj);
+            }
+            else if (obj is TDerivedType14)
+            {
+                return matchFunc14((TDerivedType14)obj);
+            }
+            else if (obj is TDerivedType15)
+            {
+                return matchFunc15((TDerivedType15)obj);
+            }
+            else if (obj is TDerivedType16)
+            {
+                return matchFunc16((TDerivedType16)obj);
+            }
+            else if (obj is TDerivedType17)
+            {
+                return matchFunc17((TDerivedType17)obj);
+            }
+            else if (obj is TDerivedType18)
+            {
+                return matchFunc18((TDerivedType18)obj);
+            }
+            else if (obj is TDerivedType19)
+            {
+                return matchFunc19((TDerivedType19)obj);
+            }
+            else if (obj is TDerivedType20)
+            {
+                return matchFunc20((TDerivedType20)obj);
+            }
+            else if (obj is TDerivedType21)
+            {
+                return matchFunc21((TDerivedType21)obj);
+            }
+            else if (obj is TDerivedType22)
+            {
+                return matchFunc22((TDerivedType22)obj);
+            }
+            else if (obj is TDerivedType23)
+            {
+                return matchFunc23((TDerivedType23)obj);
+            }
+            else if (obj is TDerivedType24)
+            {
+                return matchFunc24((TDerivedType24)obj);
+            }
+            else if (obj is TDerivedType25)
+            {
+                return matchFunc25((TDerivedType25)obj);
+            }
+            else if (obj is TDerivedType26)
+            {
+                return matchFunc26((TDerivedType26)obj);
+            }
+            else if (obj is TDerivedType27)
+            {
+                return matchFunc27((TDerivedType27)obj);
+            }
+            else if (obj is TDerivedType28)
+            {
+                return matchFunc28((TDerivedType28)obj);
+            }
+            else if (obj is TDerivedType29)
+            {
+                return matchFunc29((TDerivedType29)obj);
+            }
+            else if (obj is TDerivedType30)
+            {
+                return matchFunc30((TDerivedType30)obj);
+            }
+            else if (obj is TDerivedType31)
+            {
+                return matchFunc31((TDerivedType31)obj);
+            }
+            else if (obj is TDerivedType32)
+            {
+                return matchFunc32((TDerivedType32)obj);
+            }
+            else if (obj is TDerivedType33)
+            {
+                return matchFunc33((TDerivedType33)obj);
+            }
+            else if (obj is TDerivedType34)
+            {
+                return matchFunc34((TDerivedType34)obj);
+            }
+            else if (obj is TDerivedType35)
+            {
+                return matchFunc35((TDerivedType35)obj);
+            }
+            else if (obj is TDerivedType36)
+            {
+                return matchFunc36((TDerivedType36)obj);
+            }
+            else if (obj is TDerivedType37)
+            {
+                return matchFunc37((TDerivedType37)obj);
+            }
+            else if (obj is TDerivedType38)
+            {
+                return matchFunc38((TDerivedType38)obj);
+            }
+            else if (obj is TDerivedType39)
+            {
+                return matchFunc39((TDerivedType39)obj);
+            }
+            else if (obj is TDerivedType40)
+            {
+                return matchFunc40((TDerivedType40)obj);
+            }
+            else if (defaultFunc != null)
+            {
+                return defaultFunc(obj);
+            }
+            else
+            {
+                return default(TResult);
+            }
+        }
         #endregion
     }
 }