diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index e5aa839827019..5eb230f1c009e 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -635,16 +635,25 @@ private BoundStatement BindUsingDeclarationStatementParts(LocalDeclarationStatem
         {
             Conversion iDisposableConversion;
             MethodSymbol disposeMethod;
+            bool hasAwait = node.AwaitKeyword != default;
             var declarations = BindUsingVariableDeclaration(
                                                 this,
                                                 diagnostics,
                                                 diagnostics.HasAnyErrors(),
                                                 node,
                                                 node.Declaration,
-                                                hasAwait: false,
+                                                hasAwait,
                                                 out iDisposableConversion,
                                                 out disposeMethod);
-            return new BoundUsingLocalDeclarations(node, disposeMethod, iDisposableConversion, declarations);
+
+            AwaitableInfo awaitOpt = null;
+            bool hasErrors = false;
+            if (hasAwait)
+            {
+                awaitOpt = BindAsyncDisposeAwaiter(node, node.AwaitKeyword, disposeMethod, diagnostics, ref hasErrors);
+            }
+
+            return new BoundUsingLocalDeclarations(node, disposeMethod, iDisposableConversion, awaitOpt, declarations, hasErrors);
         }
 
         private BoundStatement BindDeclarationStatementParts(LocalDeclarationStatementSyntax node, DiagnosticBag diagnostics)
@@ -762,6 +771,29 @@ internal MethodSymbol TryFindDisposePatternMethod(BoundExpression expr, SyntaxNo
             return disposeMethod;
         }
 
+        /// <summary>
+        /// Binds an awaiter for asynchronous dispose
+        /// </summary>
+        /// <param name="node">The syntax node to bind for</param>
+        /// <param name="awaitKeyword">The await keyword of the syntax</param>
+        /// <param name="disposeMethodOpt">The dispose method to call, or null to use IAsyncDisposable.DisposeAsync</param>
+        /// <param name="diagnostics">Populated with any errors</param>
+        /// <param name="hasErrors">True if errors occurred during binding</param>
+        /// <returns>An <see cref="AwaitableInfo"/> with the bound information</returns>
+        protected AwaitableInfo BindAsyncDisposeAwaiter(SyntaxNode node, SyntaxToken awaitKeyword, MethodSymbol disposeMethodOpt, DiagnosticBag diagnostics, ref bool hasErrors)
+        {
+            TypeSymbol taskType = disposeMethodOpt is null
+                                    ? this.Compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_ValueTask)
+                                    : disposeMethodOpt.ReturnType.TypeSymbol;
+
+            hasErrors |= ReportUseSiteDiagnostics(taskType, diagnostics, awaitKeyword);
+
+            BoundExpression placeholder = new BoundAwaitableValuePlaceholder(node, taskType).MakeCompilerGenerated();
+            AwaitableInfo awaitOpt = BindAwaitInfo(placeholder, node, awaitKeyword.GetLocation(), diagnostics, ref hasErrors);
+            return awaitOpt;
+        }
+
+
         private TypeSymbolWithAnnotations BindVariableType(CSharpSyntaxNode declarationNode, DiagnosticBag diagnostics, TypeSyntax typeSyntax, ref bool isConst, out bool isVar, out AliasSymbol alias)
         {
             Debug.Assert(
diff --git a/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs b/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs
index 24a6800968cef..991e9dcec9eca 100644
--- a/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs
@@ -112,12 +112,8 @@ internal override BoundStatement BindUsingStatementParts(DiagnosticBag diagnosti
 
             if (hasAwait)
             {
-                TypeSymbol taskType = this.Compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_ValueTask);
-                hasErrors |= ReportUseSiteDiagnostics(taskType, diagnostics, _syntax.AwaitKeyword);
-
                 var resource = (SyntaxNode)expressionSyntax ?? declarationSyntax;
-                BoundExpression placeholder = new BoundAwaitableValuePlaceholder(resource, taskType).MakeCompilerGenerated();
-                awaitOpt = BindAwaitInfo(placeholder, resource, _syntax.AwaitKeyword.GetLocation(), diagnostics, ref hasErrors);
+                awaitOpt = BindAsyncDisposeAwaiter(resource, _syntax.AwaitKeyword, disposeMethod, diagnostics, ref hasErrors);
             }
 
             BoundStatement boundBody = originalBinder.BindPossibleEmbeddedStatement(_syntax.Statement, diagnostics);
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 50acf21978677..eae3fdc86172c 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -794,6 +794,7 @@
   <Node Name="BoundUsingLocalDeclarations" Base="BoundMultipleLocalDeclarations">
     <Field Name="DisposeMethodOpt" Type="MethodSymbol" Null="Allow"/>
     <Field Name="IDisposableConversion" Type="Conversion"/>
+    <Field Name="AwaitOpt" Type="AwaitableInfo" Null="allow"/>
   </Node>
 
   <!-- 
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index 5bad42e701a46..590919ca72113 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -11347,6 +11347,15 @@ internal static string IDS_FeatureUnmanagedGenericTypeConstraint {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to using declarations.
+        /// </summary>
+        internal static string IDS_FeatureUsingDeclarations {
+            get {
+                return ResourceManager.GetString("IDS_FeatureUsingDeclarations", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to using static.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index fa677d606ff44..0fae18aaf6b32 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -5640,4 +5640,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_GoToBackwardJumpOverUsingVar" xml:space="preserve">
     <value>A goto cannot jump to a location before a using declaration within the same block.</value>
   </data>
+  <data name="IDS_FeatureUsingDeclarations" xml:space="preserve">
+    <value>using declarations</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Portable/Errors/MessageID.cs b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
index b2453e79c6331..5c87048460246 100644
--- a/src/Compilers/CSharp/Portable/Errors/MessageID.cs
+++ b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
@@ -171,6 +171,7 @@ internal enum MessageID
         IDS_FeatureRangeOperator = MessageBase + 12751,
         IDS_FeatureAsyncStreams = MessageBase + 12752,
         IDS_Disposable = MessageBase + 12753,
+        IDS_FeatureUsingDeclarations = MessageBase + 12754
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -244,6 +245,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureIndexOperator: // semantic check
                 case MessageID.IDS_FeatureRangeOperator: // semantic check
                 case MessageID.IDS_FeatureAsyncStreams:
+                case MessageID.IDS_FeatureUsingDeclarations:
                     return LanguageVersion.CSharp8;
 
                 // C# 7.3 features.
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/DataFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/DataFlowPass.cs
index 6bb125215f306..74ae7c99c0e85 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/DataFlowPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/DataFlowPass.cs
@@ -259,22 +259,26 @@ protected override ImmutableArray<PendingBranch> RemoveReturns()
 
         private static bool HasAwait(PendingBranch pending)
         {
-            if (pending.Branch is null)
+            var pendingBranch = pending.Branch;
+            if (pendingBranch is null)
             {
                 return false;
             }
 
-            BoundKind kind = pending.Branch.Kind;
+            BoundKind kind = pendingBranch.Kind;
             switch (kind)
             {
                 case BoundKind.AwaitExpression:
                     return true;
                 case BoundKind.UsingStatement:
-                    var usingStatement = (BoundUsingStatement)pending.Branch;
+                    var usingStatement = (BoundUsingStatement)pendingBranch;
                     return usingStatement.AwaitOpt != null;
                 case BoundKind.ForEachStatement:
-                    var foreachStatement = (BoundForEachStatement)pending.Branch;
+                    var foreachStatement = (BoundForEachStatement)pendingBranch;
                     return foreachStatement.AwaitOpt != null;
+                case BoundKind.UsingLocalDeclarations:
+                    var localDeclaration = (BoundUsingLocalDeclarations)pendingBranch;
+                    return localDeclaration.AwaitOpt != null;
                 default:
                     return false;
             }
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs
index 0c621b3bc5153..5a29fba33cef5 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs
@@ -1861,6 +1861,10 @@ public override BoundNode VisitMultipleLocalDeclarations(BoundMultipleLocalDecla
 
         public override BoundNode VisitUsingLocalDeclarations(BoundUsingLocalDeclarations node)
         {
+            if (AwaitUsingAddsPendingBranch && node.AwaitOpt != null)
+            {
+                _pendingBranches.Add(new PendingBranch(node, this.State));
+            }
             return VisitMultipleLocalDeclarations(node);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index e588e5d177b3c..23dd4ed2b4381 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -2685,7 +2685,7 @@ public BoundMultipleLocalDeclarations Update(ImmutableArray<BoundLocalDeclaratio
 
     internal sealed partial class BoundUsingLocalDeclarations : BoundMultipleLocalDeclarations
     {
-        public BoundUsingLocalDeclarations(SyntaxNode syntax, MethodSymbol disposeMethodOpt, Conversion iDisposableConversion, ImmutableArray<BoundLocalDeclaration> localDeclarations, bool hasErrors = false)
+        public BoundUsingLocalDeclarations(SyntaxNode syntax, MethodSymbol disposeMethodOpt, Conversion iDisposableConversion, AwaitableInfo awaitOpt, ImmutableArray<BoundLocalDeclaration> localDeclarations, bool hasErrors = false)
             : base(BoundKind.UsingLocalDeclarations, syntax, localDeclarations, hasErrors || localDeclarations.HasErrors())
         {
 
@@ -2693,6 +2693,7 @@ public BoundUsingLocalDeclarations(SyntaxNode syntax, MethodSymbol disposeMethod
 
             this.DisposeMethodOpt = disposeMethodOpt;
             this.IDisposableConversion = iDisposableConversion;
+            this.AwaitOpt = awaitOpt;
         }
 
 
@@ -2700,16 +2701,18 @@ public BoundUsingLocalDeclarations(SyntaxNode syntax, MethodSymbol disposeMethod
 
         public Conversion IDisposableConversion { get; }
 
+        public AwaitableInfo AwaitOpt { get; }
+
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitUsingLocalDeclarations(this);
         }
 
-        public BoundUsingLocalDeclarations Update(MethodSymbol disposeMethodOpt, Conversion iDisposableConversion, ImmutableArray<BoundLocalDeclaration> localDeclarations)
+        public BoundUsingLocalDeclarations Update(MethodSymbol disposeMethodOpt, Conversion iDisposableConversion, AwaitableInfo awaitOpt, ImmutableArray<BoundLocalDeclaration> localDeclarations)
         {
-            if (disposeMethodOpt != this.DisposeMethodOpt || iDisposableConversion != this.IDisposableConversion || localDeclarations != this.LocalDeclarations)
+            if (disposeMethodOpt != this.DisposeMethodOpt || iDisposableConversion != this.IDisposableConversion || awaitOpt != this.AwaitOpt || localDeclarations != this.LocalDeclarations)
             {
-                var result = new BoundUsingLocalDeclarations(this.Syntax, disposeMethodOpt, iDisposableConversion, localDeclarations, this.HasErrors);
+                var result = new BoundUsingLocalDeclarations(this.Syntax, disposeMethodOpt, iDisposableConversion, awaitOpt, localDeclarations, this.HasErrors);
                 result.WasCompilerGenerated = this.WasCompilerGenerated;
                 return result;
             }
@@ -9538,7 +9541,7 @@ public override BoundNode VisitMultipleLocalDeclarations(BoundMultipleLocalDecla
         public override BoundNode VisitUsingLocalDeclarations(BoundUsingLocalDeclarations node)
         {
             ImmutableArray<BoundLocalDeclaration> localDeclarations = (ImmutableArray<BoundLocalDeclaration>)this.VisitList(node.LocalDeclarations);
-            return node.Update(node.DisposeMethodOpt, node.IDisposableConversion, localDeclarations);
+            return node.Update(node.DisposeMethodOpt, node.IDisposableConversion, node.AwaitOpt, localDeclarations);
         }
         public override BoundNode VisitLocalFunctionStatement(BoundLocalFunctionStatement node)
         {
@@ -10783,6 +10786,7 @@ public override TreeDumperNode VisitUsingLocalDeclarations(BoundUsingLocalDeclar
             {
                 new TreeDumperNode("disposeMethodOpt", node.DisposeMethodOpt, null),
                 new TreeDumperNode("iDisposableConversion", node.IDisposableConversion, null),
+                new TreeDumperNode("awaitOpt", node.AwaitOpt, null),
                 new TreeDumperNode("localDeclarations", null, from x in node.LocalDeclarations select Visit(x, null))
             }
             );
diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs
index 4bdc74e1927d5..943a03db47332 100644
--- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs
@@ -12472,15 +12472,21 @@ static LocalFunctionStatementSyntax()
 
   internal sealed partial class LocalDeclarationStatementSyntax : StatementSyntax
   {
+    internal readonly SyntaxToken awaitKeyword;
     internal readonly SyntaxToken usingKeyword;
     internal readonly GreenNode modifiers;
     internal readonly VariableDeclarationSyntax declaration;
     internal readonly SyntaxToken semicolonToken;
 
-    internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken usingKeyword, GreenNode modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
+    internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken awaitKeyword, SyntaxToken usingKeyword, GreenNode modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
         : base(kind, diagnostics, annotations)
     {
-        this.SlotCount = 4;
+        this.SlotCount = 5;
+        if (awaitKeyword != null)
+        {
+            this.AdjustFlagsAndWidth(awaitKeyword);
+            this.awaitKeyword = awaitKeyword;
+        }
         if (usingKeyword != null)
         {
             this.AdjustFlagsAndWidth(usingKeyword);
@@ -12498,11 +12504,16 @@ internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken usingKeywo
     }
 
 
-    internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken usingKeyword, GreenNode modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken, SyntaxFactoryContext context)
+    internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken awaitKeyword, SyntaxToken usingKeyword, GreenNode modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken, SyntaxFactoryContext context)
         : base(kind)
     {
         this.SetFactoryContext(context);
-        this.SlotCount = 4;
+        this.SlotCount = 5;
+        if (awaitKeyword != null)
+        {
+            this.AdjustFlagsAndWidth(awaitKeyword);
+            this.awaitKeyword = awaitKeyword;
+        }
         if (usingKeyword != null)
         {
             this.AdjustFlagsAndWidth(usingKeyword);
@@ -12520,10 +12531,15 @@ internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken usingKeywo
     }
 
 
-    internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken usingKeyword, GreenNode modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+    internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken awaitKeyword, SyntaxToken usingKeyword, GreenNode modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
         : base(kind)
     {
-        this.SlotCount = 4;
+        this.SlotCount = 5;
+        if (awaitKeyword != null)
+        {
+            this.AdjustFlagsAndWidth(awaitKeyword);
+            this.awaitKeyword = awaitKeyword;
+        }
         if (usingKeyword != null)
         {
             this.AdjustFlagsAndWidth(usingKeyword);
@@ -12540,6 +12556,7 @@ internal LocalDeclarationStatementSyntax(SyntaxKind kind, SyntaxToken usingKeywo
         this.semicolonToken = semicolonToken;
     }
 
+    public SyntaxToken AwaitKeyword { get { return this.awaitKeyword; } }
     public SyntaxToken UsingKeyword { get { return this.usingKeyword; } }
     /// <summary>Gets the modifier list.</summary>
     public Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> Modifiers { get { return new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken>(this.modifiers); } }
@@ -12550,10 +12567,11 @@ internal override GreenNode GetSlot(int index)
     {
         switch (index)
         {
-            case 0: return this.usingKeyword;
-            case 1: return this.modifiers;
-            case 2: return this.declaration;
-            case 3: return this.semicolonToken;
+            case 0: return this.awaitKeyword;
+            case 1: return this.usingKeyword;
+            case 2: return this.modifiers;
+            case 3: return this.declaration;
+            case 4: return this.semicolonToken;
             default: return null;
         }
     }
@@ -12573,11 +12591,11 @@ public override void Accept(CSharpSyntaxVisitor visitor)
         visitor.VisitLocalDeclarationStatement(this);
     }
 
-    public LocalDeclarationStatementSyntax Update(SyntaxToken usingKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+    public LocalDeclarationStatementSyntax Update(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
     {
-        if (usingKeyword != this.UsingKeyword || modifiers != this.Modifiers || declaration != this.Declaration || semicolonToken != this.SemicolonToken)
+        if (awaitKeyword != this.AwaitKeyword || usingKeyword != this.UsingKeyword || modifiers != this.Modifiers || declaration != this.Declaration || semicolonToken != this.SemicolonToken)
         {
-            var newNode = SyntaxFactory.LocalDeclarationStatement(usingKeyword, modifiers, declaration, semicolonToken);
+            var newNode = SyntaxFactory.LocalDeclarationStatement(awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken);
             var diags = this.GetDiagnostics();
             if (diags != null && diags.Length > 0)
                newNode = newNode.WithDiagnosticsGreen(diags);
@@ -12592,18 +12610,24 @@ public LocalDeclarationStatementSyntax Update(SyntaxToken usingKeyword, Microsof
 
     internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
     {
-         return new LocalDeclarationStatementSyntax(this.Kind, this.usingKeyword, this.modifiers, this.declaration, this.semicolonToken, diagnostics, GetAnnotations());
+         return new LocalDeclarationStatementSyntax(this.Kind, this.awaitKeyword, this.usingKeyword, this.modifiers, this.declaration, this.semicolonToken, diagnostics, GetAnnotations());
     }
 
     internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
     {
-         return new LocalDeclarationStatementSyntax(this.Kind, this.usingKeyword, this.modifiers, this.declaration, this.semicolonToken, GetDiagnostics(), annotations);
+         return new LocalDeclarationStatementSyntax(this.Kind, this.awaitKeyword, this.usingKeyword, this.modifiers, this.declaration, this.semicolonToken, GetDiagnostics(), annotations);
     }
 
     internal LocalDeclarationStatementSyntax(ObjectReader reader)
         : base(reader)
     {
-      this.SlotCount = 4;
+      this.SlotCount = 5;
+      var awaitKeyword = (SyntaxToken)reader.ReadValue();
+      if (awaitKeyword != null)
+      {
+         AdjustFlagsAndWidth(awaitKeyword);
+         this.awaitKeyword = awaitKeyword;
+      }
       var usingKeyword = (SyntaxToken)reader.ReadValue();
       if (usingKeyword != null)
       {
@@ -12633,6 +12657,7 @@ internal LocalDeclarationStatementSyntax(ObjectReader reader)
     internal override void WriteTo(ObjectWriter writer)
     {
       base.WriteTo(writer);
+      writer.WriteValue(this.awaitKeyword);
       writer.WriteValue(this.usingKeyword);
       writer.WriteValue(this.modifiers);
       writer.WriteValue(this.declaration);
@@ -37020,11 +37045,12 @@ public override CSharpSyntaxNode VisitLocalFunctionStatement(LocalFunctionStatem
 
     public override CSharpSyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
     {
+      var awaitKeyword = (SyntaxToken)this.Visit(node.AwaitKeyword);
       var usingKeyword = (SyntaxToken)this.Visit(node.UsingKeyword);
       var modifiers = this.VisitList(node.Modifiers);
       var declaration = (VariableDeclarationSyntax)this.Visit(node.Declaration);
       var semicolonToken = (SyntaxToken)this.Visit(node.SemicolonToken);
-      return node.Update(usingKeyword, modifiers, declaration, semicolonToken);
+      return node.Update(awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken);
     }
 
     public override CSharpSyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
@@ -40904,9 +40930,20 @@ public LocalFunctionStatementSyntax LocalFunctionStatement(Microsoft.CodeAnalysi
       return new LocalFunctionStatementSyntax(SyntaxKind.LocalFunctionStatement, modifiers.Node, returnType, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken, this.context);
     }
 
-    public LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken usingKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+    public LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
     {
 #if DEBUG
+      if (awaitKeyword != null)
+      {
+      switch (awaitKeyword.Kind)
+      {
+        case SyntaxKind.AwaitKeyword:
+        case SyntaxKind.None:
+          break;
+        default:
+          throw new ArgumentException("awaitKeyword");
+      }
+      }
       if (usingKeyword != null)
       {
       switch (usingKeyword.Kind)
@@ -40931,7 +40968,7 @@ public LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken usi
       }
 #endif
 
-      return new LocalDeclarationStatementSyntax(SyntaxKind.LocalDeclarationStatement, usingKeyword, modifiers.Node, declaration, semicolonToken, this.context);
+      return new LocalDeclarationStatementSyntax(SyntaxKind.LocalDeclarationStatement, awaitKeyword, usingKeyword, modifiers.Node, declaration, semicolonToken, this.context);
     }
 
     public VariableDeclarationSyntax VariableDeclaration(TypeSyntax type, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<VariableDeclaratorSyntax> variables)
@@ -47991,9 +48028,20 @@ public static LocalFunctionStatementSyntax LocalFunctionStatement(Microsoft.Code
       return new LocalFunctionStatementSyntax(SyntaxKind.LocalFunctionStatement, modifiers.Node, returnType, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken);
     }
 
-    public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken usingKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+    public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<SyntaxToken> modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
     {
 #if DEBUG
+      if (awaitKeyword != null)
+      {
+      switch (awaitKeyword.Kind)
+      {
+        case SyntaxKind.AwaitKeyword:
+        case SyntaxKind.None:
+          break;
+        default:
+          throw new ArgumentException("awaitKeyword");
+      }
+      }
       if (usingKeyword != null)
       {
       switch (usingKeyword.Kind)
@@ -48018,7 +48066,7 @@ public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTo
       }
 #endif
 
-      return new LocalDeclarationStatementSyntax(SyntaxKind.LocalDeclarationStatement, usingKeyword, modifiers.Node, declaration, semicolonToken);
+      return new LocalDeclarationStatementSyntax(SyntaxKind.LocalDeclarationStatement, awaitKeyword, usingKeyword, modifiers.Node, declaration, semicolonToken);
     }
 
     public static VariableDeclarationSyntax VariableDeclaration(TypeSyntax type, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<VariableDeclaratorSyntax> variables)
diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs
index 7c17b809ed20d..5075169558bc2 100644
--- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs
@@ -3170,11 +3170,12 @@ public override SyntaxNode VisitLocalFunctionStatement(LocalFunctionStatementSyn
 
     public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
     {
+      var awaitKeyword = this.VisitToken(node.AwaitKeyword);
       var usingKeyword = this.VisitToken(node.UsingKeyword);
       var modifiers = this.VisitList(node.Modifiers);
       var declaration = (VariableDeclarationSyntax)this.Visit(node.Declaration);
       var semicolonToken = this.VisitToken(node.SemicolonToken);
-      return node.Update(usingKeyword, modifiers, declaration, semicolonToken);
+      return node.Update(awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken);
     }
 
     public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
@@ -6869,8 +6870,16 @@ public static LocalFunctionStatementSyntax LocalFunctionStatement(TypeSyntax ret
     }
 
     /// <summary>Creates a new LocalDeclarationStatementSyntax instance.</summary>
-    public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken usingKeyword, SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+    public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
     {
+      switch (awaitKeyword.Kind())
+      {
+        case SyntaxKind.AwaitKeyword:
+        case SyntaxKind.None:
+          break;
+        default:
+          throw new ArgumentException("awaitKeyword");
+      }
       switch (usingKeyword.Kind())
       {
         case SyntaxKind.UsingKeyword:
@@ -6888,20 +6897,20 @@ public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTo
         default:
           throw new ArgumentException("semicolonToken");
       }
-      return (LocalDeclarationStatementSyntax)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LocalDeclarationStatement((Syntax.InternalSyntax.SyntaxToken)usingKeyword.Node, modifiers.Node.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxToken>(), declaration == null ? null : (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)declaration.Green, (Syntax.InternalSyntax.SyntaxToken)semicolonToken.Node).CreateRed();
+      return (LocalDeclarationStatementSyntax)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LocalDeclarationStatement((Syntax.InternalSyntax.SyntaxToken)awaitKeyword.Node, (Syntax.InternalSyntax.SyntaxToken)usingKeyword.Node, modifiers.Node.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxToken>(), declaration == null ? null : (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)declaration.Green, (Syntax.InternalSyntax.SyntaxToken)semicolonToken.Node).CreateRed();
     }
 
 
     /// <summary>Creates a new LocalDeclarationStatementSyntax instance.</summary>
     public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration)
     {
-      return SyntaxFactory.LocalDeclarationStatement(default(SyntaxToken), modifiers, declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+      return SyntaxFactory.LocalDeclarationStatement(default(SyntaxToken), default(SyntaxToken), modifiers, declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken));
     }
 
     /// <summary>Creates a new LocalDeclarationStatementSyntax instance.</summary>
     public static LocalDeclarationStatementSyntax LocalDeclarationStatement(VariableDeclarationSyntax declaration)
     {
-      return SyntaxFactory.LocalDeclarationStatement(default(SyntaxToken), default(SyntaxTokenList), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+      return SyntaxFactory.LocalDeclarationStatement(default(SyntaxToken), default(SyntaxToken), default(SyntaxTokenList), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken));
     }
 
     /// <summary>Creates a new VariableDeclarationSyntax instance.</summary>
diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs
index 594c2aea429ec..a6cd8a1c5e71f 100644
--- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs
@@ -7831,13 +7831,25 @@ internal LocalDeclarationStatementSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.In
     {
     }
 
+    public SyntaxToken AwaitKeyword 
+    {
+        get
+        {
+            var slot = ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LocalDeclarationStatementSyntax)this.Green).awaitKeyword;
+            if (slot != null)
+                return new SyntaxToken(this, slot, this.Position, 0);
+
+            return default(SyntaxToken);
+        }
+    }
+
     public SyntaxToken UsingKeyword 
     {
         get
         {
             var slot = ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LocalDeclarationStatementSyntax)this.Green).usingKeyword;
             if (slot != null)
-                return new SyntaxToken(this, slot, this.Position, 0);
+                return new SyntaxToken(this, slot, this.GetChildPosition(1), this.GetChildIndex(1));
 
             return default(SyntaxToken);
         }
@@ -7848,9 +7860,9 @@ public SyntaxTokenList Modifiers
     {
         get
         {
-            var slot = this.Green.GetSlot(1);
+            var slot = this.Green.GetSlot(2);
             if (slot != null)
-                return new SyntaxTokenList(this, slot, this.GetChildPosition(1), this.GetChildIndex(1));
+                return new SyntaxTokenList(this, slot, this.GetChildPosition(2), this.GetChildIndex(2));
 
             return default(SyntaxTokenList);
         }
@@ -7860,20 +7872,20 @@ public VariableDeclarationSyntax Declaration
     {
         get
         {
-            return this.GetRed(ref this.declaration, 2);
+            return this.GetRed(ref this.declaration, 3);
         }
     }
 
     public SyntaxToken SemicolonToken 
     {
-      get { return new SyntaxToken(this, ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LocalDeclarationStatementSyntax)this.Green).semicolonToken, this.GetChildPosition(3), this.GetChildIndex(3)); }
+      get { return new SyntaxToken(this, ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LocalDeclarationStatementSyntax)this.Green).semicolonToken, this.GetChildPosition(4), this.GetChildIndex(4)); }
     }
 
     internal override SyntaxNode GetNodeSlot(int index)
     {
         switch (index)
         {
-            case 2: return this.GetRed(ref this.declaration, 2);
+            case 3: return this.GetRed(ref this.declaration, 3);
             default: return null;
         }
     }
@@ -7881,7 +7893,7 @@ internal override SyntaxNode GetCachedSlot(int index)
     {
         switch (index)
         {
-            case 2: return this.declaration;
+            case 3: return this.declaration;
             default: return null;
         }
     }
@@ -7896,11 +7908,11 @@ public override void Accept(CSharpSyntaxVisitor visitor)
         visitor.VisitLocalDeclarationStatement(this);
     }
 
-    public LocalDeclarationStatementSyntax Update(SyntaxToken usingKeyword, SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+    public LocalDeclarationStatementSyntax Update(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
     {
-        if (usingKeyword != this.UsingKeyword || modifiers != this.Modifiers || declaration != this.Declaration || semicolonToken != this.SemicolonToken)
+        if (awaitKeyword != this.AwaitKeyword || usingKeyword != this.UsingKeyword || modifiers != this.Modifiers || declaration != this.Declaration || semicolonToken != this.SemicolonToken)
         {
-            var newNode = SyntaxFactory.LocalDeclarationStatement(usingKeyword, modifiers, declaration, semicolonToken);
+            var newNode = SyntaxFactory.LocalDeclarationStatement(awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken);
             var annotations = this.GetAnnotations();
             if (annotations != null && annotations.Length > 0)
                return newNode.WithAnnotations(annotations);
@@ -7910,24 +7922,29 @@ public LocalDeclarationStatementSyntax Update(SyntaxToken usingKeyword, SyntaxTo
         return this;
     }
 
+    public LocalDeclarationStatementSyntax WithAwaitKeyword(SyntaxToken awaitKeyword)
+    {
+        return this.Update(awaitKeyword, this.UsingKeyword, this.Modifiers, this.Declaration, this.SemicolonToken);
+    }
+
     public LocalDeclarationStatementSyntax WithUsingKeyword(SyntaxToken usingKeyword)
     {
-        return this.Update(usingKeyword, this.Modifiers, this.Declaration, this.SemicolonToken);
+        return this.Update(this.AwaitKeyword, usingKeyword, this.Modifiers, this.Declaration, this.SemicolonToken);
     }
 
     public LocalDeclarationStatementSyntax WithModifiers(SyntaxTokenList modifiers)
     {
-        return this.Update(this.UsingKeyword, modifiers, this.Declaration, this.SemicolonToken);
+        return this.Update(this.AwaitKeyword, this.UsingKeyword, modifiers, this.Declaration, this.SemicolonToken);
     }
 
     public LocalDeclarationStatementSyntax WithDeclaration(VariableDeclarationSyntax declaration)
     {
-        return this.Update(this.UsingKeyword, this.Modifiers, declaration, this.SemicolonToken);
+        return this.Update(this.AwaitKeyword, this.UsingKeyword, this.Modifiers, declaration, this.SemicolonToken);
     }
 
     public LocalDeclarationStatementSyntax WithSemicolonToken(SyntaxToken semicolonToken)
     {
-        return this.Update(this.UsingKeyword, this.Modifiers, this.Declaration, semicolonToken);
+        return this.Update(this.AwaitKeyword, this.UsingKeyword, this.Modifiers, this.Declaration, semicolonToken);
     }
 
     public LocalDeclarationStatementSyntax AddModifiers(params SyntaxToken[] items)
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncExceptionHandlerRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncExceptionHandlerRewriter.cs
index 14377c9df5b83..1fe3a82567d2b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncExceptionHandlerRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncExceptionHandlerRewriter.cs
@@ -138,7 +138,8 @@ public override BoundNode VisitTryStatement(BoundTryStatement node)
                 tryStatementSyntax.IsKind(SyntaxKind.TryStatement) ||
                 tryStatementSyntax.IsKind(SyntaxKind.UsingStatement) ||
                 tryStatementSyntax.IsKind(SyntaxKind.ForEachStatement) ||
-                tryStatementSyntax.IsKind(SyntaxKind.ForEachVariableStatement));
+                tryStatementSyntax.IsKind(SyntaxKind.ForEachVariableStatement) ||
+                tryStatementSyntax.IsKind(SyntaxKind.LocalDeclarationStatement));   //PROTOTYPE: Test this with Edit-and-Continue
 
             BoundStatement finalizedRegion;
             BoundBlock rewrittenFinally;
@@ -893,10 +894,11 @@ public AwaitFinallyFrame(AwaitFinallyFrame parent, HashSet<LabelSymbol> labelsOp
                 Debug.Assert(parent != null);
                 Debug.Assert(statementSyntax != null);
 
-                Debug.Assert(statementSyntax.Kind() == SyntaxKind.TryStatement || 
+                Debug.Assert(statementSyntax.Kind() == SyntaxKind.TryStatement ||
                     (statementSyntax.Kind() == SyntaxKind.UsingStatement && ((UsingStatementSyntax)statementSyntax).AwaitKeyword != default) ||
                     (statementSyntax.Kind() == SyntaxKind.ForEachStatement && ((CommonForEachStatementSyntax)statementSyntax).AwaitKeyword != default) ||
-                    (statementSyntax.Kind() == SyntaxKind.ForEachVariableStatement && ((CommonForEachStatementSyntax)statementSyntax).AwaitKeyword != default));
+                    (statementSyntax.Kind() == SyntaxKind.ForEachVariableStatement && ((CommonForEachStatementSyntax)statementSyntax).AwaitKeyword != default) ||
+                    (statementSyntax.Kind() == SyntaxKind.LocalDeclarationStatement && ((LocalDeclarationStatementSyntax)statementSyntax).AwaitKeyword != default));
 
                 this.ParentOpt = parent;
                 this.LabelsOpt = labelsOpt;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UsingStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UsingStatement.cs
index 8a4c70d14753d..6ed4141a2d747 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UsingStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UsingStatement.cs
@@ -79,11 +79,11 @@ private BoundStatement MakeDeclarationUsingStatement(SyntaxNode syntax,
         }
 
         /// <summary>
-        /// Lower "using var x = (expression)" to a try-finally block.
+        /// Lower "[await] using var x = (expression)" to a try-finally block.
         /// </summary>
         private BoundStatement MakeLocalUsingDeclarationStatement(BoundUsingLocalDeclarations usingDeclarations, ImmutableArray<BoundStatement> statements)
         {
-            SyntaxNode syntax = usingDeclarations.Syntax;
+            LocalDeclarationStatementSyntax syntax = (LocalDeclarationStatementSyntax)usingDeclarations.Syntax;
             BoundBlock body = new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements);
             
             //PROTOTYPE: need to handle await using when boundMultipleLocalDeclarations supports it
@@ -93,8 +93,8 @@ private BoundStatement MakeLocalUsingDeclarationStatement(BoundUsingLocalDeclara
                                                                usingDeclarations.LocalDeclarations, 
                                                                usingDeclarations.IDisposableConversion,
                                                                usingDeclarations.DisposeMethodOpt, 
-                                                               awaitOpt: null, 
-                                                               awaitKeyword: default);
+                                                               awaitOpt: usingDeclarations.AwaitOpt, 
+                                                               awaitKeyword: syntax.AwaitKeyword);
 
             return usingStatement;
         }
diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index c304c2679e2d1..8a2e35cfc6fe8 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -590,7 +590,7 @@ private void ParseNamespaceBody(ref SyntaxToken openBrace, ref NamespaceBodyBuil
                                 // incomplete members must be processed before we add any nodes to the body:
                                 AddIncompleteMembers(ref pendingIncompleteMembers, ref body);
 
-                                body.Members.Add(_syntaxFactory.GlobalStatement(ParseUsingStatement(awaitTokenOpt: default)));
+                                body.Members.Add(_syntaxFactory.GlobalStatement(ParseUsingStatement()));
                                 seen = NamespaceParts.MembersAndStatements;
                             }
                             else
@@ -6695,7 +6695,7 @@ private StatementSyntax ParseStatementNoDeclaration(bool allowAnyExpression)
                     }
                     break;
                 case SyntaxKind.UsingKeyword:
-                    return PeekToken(1).Kind == SyntaxKind.OpenParenToken || (PeekToken(1).ContextualKind == SyntaxKind.AwaitKeyword && PeekToken(2).Kind == SyntaxKind.OpenParenToken) ? this.ParseUsingStatement(awaitTokenOpt: default) : this.ParseLocalDeclarationStatement();
+                    return PeekToken(1).Kind == SyntaxKind.OpenParenToken ? this.ParseUsingStatement() : this.ParseLocalDeclarationStatement();
                 case SyntaxKind.WhileKeyword:
                     return this.ParseWhileStatement();
                 case SyntaxKind.OpenBraceToken:
@@ -6709,7 +6709,14 @@ private StatementSyntax ParseStatementNoDeclaration(bool allowAnyExpression)
                     }
                     else if (isPossibleAwaitUsing())
                     {
-                        return this.ParseUsingStatement(parseAwaitKeywordForAsyncStreams());
+                        if (PeekToken(2).Kind == SyntaxKind.OpenParenToken)
+                        {
+                            return this.ParseUsingStatement(parseAwaitKeywordForAsyncStreams());
+                        }
+                        else
+                        {
+                            return this.ParseLocalDeclarationStatement(parseAwaitKeywordForAsyncStreams());
+                        }
                     }
                     else if (this.IsPossibleLabeledStatement())
                     {
@@ -8148,7 +8155,7 @@ private UnsafeStatementSyntax ParseUnsafeStatement()
             return _syntaxFactory.UnsafeStatement(@unsafe, block);
         }
 
-        private UsingStatementSyntax ParseUsingStatement(SyntaxToken awaitTokenOpt)
+        private UsingStatementSyntax ParseUsingStatement(SyntaxToken awaitTokenOpt = default)
         {
             var @using = this.EatToken(SyntaxKind.UsingKeyword);
             var openParen = this.EatToken(SyntaxKind.OpenParenToken);
@@ -8289,9 +8296,14 @@ private LabeledStatementSyntax ParseLabeledStatement()
         /// <summary>
         /// Parses any kind of local declaration statement: local variable or local function.
         /// </summary>
-        private StatementSyntax ParseLocalDeclarationStatement()
+        private StatementSyntax ParseLocalDeclarationStatement(SyntaxToken awaitKeywordOpt = default)
         {
             var usingKeyword = this.CurrentToken.Kind == SyntaxKind.UsingKeyword ? this.EatToken() : null;
+            if (usingKeyword != null)
+            {
+                usingKeyword = CheckFeatureAvailability(usingKeyword, MessageID.IDS_FeatureUsingDeclarations);
+            }
+
             var mods = _pool.Allocate();
             this.ParseDeclarationModifiers(mods);
 
@@ -8301,7 +8313,7 @@ private StatementSyntax ParseLocalDeclarationStatement()
                 TypeSyntax type;
                 LocalFunctionStatementSyntax localFunction;
                 this.ParseLocalDeclaration(variables,
-                    allowLocalFunctions: true,
+                    allowLocalFunctions: usingKeyword == default,
                     mods: mods.ToList(),
                     type: out type,
                     localFunction: out localFunction);
@@ -8332,6 +8344,7 @@ private StatementSyntax ParseLocalDeclarationStatement()
                 // PROTOTYPE
                 var semicolon = this.EatToken(SyntaxKind.SemicolonToken);
                 return _syntaxFactory.LocalDeclarationStatement(
+                    awaitKeywordOpt,
                     usingKeyword,
                     mods.ToList(),
                     _syntaxFactory.VariableDeclaration(type, variables),
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index 47ff79eb6d592..344901989c264 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -1,6 +1,9 @@
 *REMOVED*static Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.TryParse(this string version, out Microsoft.CodeAnalysis.CSharp.LanguageVersion result) -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.NullableKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.SettingToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken nullableKeyword, Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
@@ -93,7 +96,6 @@ Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Update(Microsoft.Code
 Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithLeftOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithRightOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.UsingKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
@@ -149,6 +151,7 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken nullableKeyword, Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken settingToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseMemberDeclaration(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
@@ -160,4 +163,3 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableDirective
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax node) -> TResult
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax node) -> TResult
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
diff --git a/src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs
index 2a7205d308395..1937e9ab266cb 100644
--- a/src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs
@@ -13,7 +13,7 @@ public StackAllocArrayCreationExpressionSyntax Update(SyntaxToken stackAllocKeyw
     public partial class LocalDeclarationStatementSyntax
     {
         public LocalDeclarationStatementSyntax Update(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
-            => Update(default(SyntaxToken), modifiers, declaration, semicolonToken);
+            => Update(default(SyntaxToken), default(SyntaxToken), modifiers, declaration, semicolonToken);
     }
 }
 
@@ -25,6 +25,6 @@ public static StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExp
             => StackAllocArrayCreationExpression(stackAllocKeyword, type, default(InitializerExpressionSyntax));
 
         public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
-            => LocalDeclarationStatement(default(SyntaxToken), modifiers, declaration, semicolonToken);
+            => LocalDeclarationStatement(default(SyntaxToken), default(SyntaxToken), modifiers, declaration, semicolonToken);
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
index f5feb251d365c..acfc8924efab9 100644
--- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
+++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
@@ -1890,6 +1890,9 @@
 
   <Node Name="LocalDeclarationStatementSyntax" Base="StatementSyntax">
     <Kind Name="LocalDeclarationStatement"/>
+    <Field Name="AwaitKeyword" Type="SyntaxToken" Optional="true">
+      <Kind Name="AwaitKeyword"/>
+    </Field>
     <Field Name="UsingKeyword" Type="SyntaxToken" Optional="true">
       <Kind Name="UsingKeyword"/>
     </Field>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index d1e57d96df38f..8595288d9db23 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 62102c4e58ca9..79efd6bdda990 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 8afc099be7347..8f1205317f817 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index 013b72e7043ff..58c46c3d8df67 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 280682ee63000..b26c44a0f780e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 368da7bfe9301..f4b2c5a212485 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 69185926e57b1..530de4813f550 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 24ba91d144be4..dc522eae45e81 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 5ac29c27e962f..ec91f21b7cf78 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index be296b6c3d543..2c96e773ce0a1 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 7aec4bd302dde..6335235621dea 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index ae09c247e52a8..99f1e728803e5 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 39d1c742967ef..a4ac8b9e56f95 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -307,6 +307,11 @@
         <target state="new">unmanaged generic type constraints</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureUsingDeclarations">
+        <source>using declarations</source>
+        <target state="new">using declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_InjectedDeclaration">
         <source>injected declaration</source>
         <target state="new">injected declaration</target>
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs
index 807f0ae6874a0..051597309c39f 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs
@@ -1,10 +1,21 @@
-using Roslyn.Test.Utilities;
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
 {
     public class CodeGenUsingDeclarationTests : EmitMetadataTestBase
     {
+        private const string _asyncDisposable = @"
+namespace System
+{
+    public interface IAsyncDisposable
+    {
+        System.Threading.Tasks.ValueTask DisposeAsync();
+    }
+}";
+
         [Fact]
         public void UsingVariableVarEmitTest()
         {
@@ -617,6 +628,478 @@ .locals init (C1 V_0, //x
 ");
         }
 
+        [Fact]
+        public void InsideTryCatchFinallyBlocksAsync()
+        {
+            string source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    public string Text { get; set; }
+
+    public C1(string text)
+    {
+        Text = text;
+        Console.WriteLine($""Created {Text}"");
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        Console.WriteLine($""Dispose Async {Text}"");
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+class C2
+{
+    public static async Task Main()                                                                                                           
+    {
+        try
+        {
+            await using var x = new C1(""Try"");
+            throw new Exception();
+        }
+        catch
+        {
+            await using var x =  new C1(""Catch"");
+        }
+        finally
+        {
+            await using var x = new C1(""Finally"");
+        }
+    }
+}";
+            string expectedOutput = @"
+Created Try
+Dispose Async Try
+Created Catch
+Dispose Async Catch
+Created Finally
+Dispose Async Finally
+";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: expectedOutput).VerifyIL("C2.<Main>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      906 (0x38a)
+  .maxstack  3
+  .locals init (int V_0,
+                object V_1,
+                System.Runtime.CompilerServices.ValueTaskAwaiter V_2,
+                System.Threading.Tasks.ValueTask V_3,
+                C2.<Main>d__0 V_4,
+                System.Exception V_5,
+                int V_6,
+                object V_7,
+                System.Runtime.CompilerServices.ValueTaskAwaiter V_8,
+                System.Runtime.CompilerServices.ValueTaskAwaiter V_9)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int C2.<Main>d__0.<>1__state""
+  IL_0006:  stloc.0
+  .try
+  {
+    IL_0007:  ldloc.0
+    IL_0008:  ldc.i4.1
+    IL_0009:  ble.un.s   IL_0013
+    IL_000b:  br.s       IL_000d
+    IL_000d:  ldloc.0
+    IL_000e:  ldc.i4.2
+    IL_000f:  beq.s      IL_0015
+    IL_0011:  br.s       IL_001a
+    IL_0013:  br.s       IL_0029
+    IL_0015:  br         IL_02be
+    IL_001a:  nop
+    IL_001b:  ldarg.0
+    IL_001c:  ldnull
+    IL_001d:  stfld      ""object C2.<Main>d__0.<>s__1""
+    IL_0022:  ldarg.0
+    IL_0023:  ldc.i4.0
+    IL_0024:  stfld      ""int C2.<Main>d__0.<>s__2""
+    IL_0029:  nop
+    .try
+    {
+      IL_002a:  ldloc.0
+      IL_002b:  brfalse.s  IL_0035
+      IL_002d:  br.s       IL_002f
+      IL_002f:  ldloc.0
+      IL_0030:  ldc.i4.1
+      IL_0031:  beq.s      IL_0037
+      IL_0033:  br.s       IL_003c
+      IL_0035:  br.s       IL_0043
+      IL_0037:  br         IL_01c7
+      IL_003c:  ldarg.0
+      IL_003d:  ldc.i4.0
+      IL_003e:  stfld      ""int C2.<Main>d__0.<>s__4""
+      IL_0043:  nop
+      .try
+      {
+        IL_0044:  ldloc.0
+        IL_0045:  brfalse.s  IL_0049
+        IL_0047:  br.s       IL_004b
+        IL_0049:  br.s       IL_00c7
+        IL_004b:  nop
+        IL_004c:  ldarg.0
+        IL_004d:  ldstr      ""Try""
+        IL_0052:  newobj     ""C1..ctor(string)""
+        IL_0057:  stfld      ""C1 C2.<Main>d__0.<x>5__5""
+        IL_005c:  ldarg.0
+        IL_005d:  ldnull
+        IL_005e:  stfld      ""object C2.<Main>d__0.<>s__6""
+        IL_0063:  ldarg.0
+        IL_0064:  ldc.i4.0
+        IL_0065:  stfld      ""int C2.<Main>d__0.<>s__7""
+        .try
+        {
+          IL_006a:  newobj     ""System.Exception..ctor()""
+          IL_006f:  throw
+        }
+        catch object
+        {
+          IL_0070:  stloc.1
+          IL_0071:  ldarg.0
+          IL_0072:  ldloc.1
+          IL_0073:  stfld      ""object C2.<Main>d__0.<>s__6""
+          IL_0078:  leave.s    IL_007a
+        }
+        IL_007a:  ldarg.0
+        IL_007b:  ldfld      ""C1 C2.<Main>d__0.<x>5__5""
+        IL_0080:  brfalse.s  IL_00eb
+        IL_0082:  ldarg.0
+        IL_0083:  ldfld      ""C1 C2.<Main>d__0.<x>5__5""
+        IL_0088:  callvirt   ""System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()""
+        IL_008d:  stloc.3
+        IL_008e:  ldloca.s   V_3
+        IL_0090:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+        IL_0095:  stloc.2
+        IL_0096:  ldloca.s   V_2
+        IL_0098:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+        IL_009d:  brtrue.s   IL_00e3
+        IL_009f:  ldarg.0
+        IL_00a0:  ldc.i4.0
+        IL_00a1:  dup
+        IL_00a2:  stloc.0
+        IL_00a3:  stfld      ""int C2.<Main>d__0.<>1__state""
+        IL_00a8:  ldarg.0
+        IL_00a9:  ldloc.2
+        IL_00aa:  stfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+        IL_00af:  ldarg.0
+        IL_00b0:  stloc.s    V_4
+        IL_00b2:  ldarg.0
+        IL_00b3:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C2.<Main>d__0.<>t__builder""
+        IL_00b8:  ldloca.s   V_2
+        IL_00ba:  ldloca.s   V_4
+        IL_00bc:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.ValueTaskAwaiter, C2.<Main>d__0>(ref System.Runtime.CompilerServices.ValueTaskAwaiter, ref C2.<Main>d__0)""
+        IL_00c1:  nop
+        IL_00c2:  leave      IL_0389
+        IL_00c7:  ldarg.0
+        IL_00c8:  ldfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+        IL_00cd:  stloc.2
+        IL_00ce:  ldarg.0
+        IL_00cf:  ldflda     ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+        IL_00d4:  initobj    ""System.Runtime.CompilerServices.ValueTaskAwaiter""
+        IL_00da:  ldarg.0
+        IL_00db:  ldc.i4.m1
+        IL_00dc:  dup
+        IL_00dd:  stloc.0
+        IL_00de:  stfld      ""int C2.<Main>d__0.<>1__state""
+        IL_00e3:  ldloca.s   V_2
+        IL_00e5:  call       ""void System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult()""
+        IL_00ea:  nop
+        IL_00eb:  ldarg.0
+        IL_00ec:  ldfld      ""object C2.<Main>d__0.<>s__6""
+        IL_00f1:  stloc.1
+        IL_00f2:  ldloc.1
+        IL_00f3:  brfalse.s  IL_0110
+        IL_00f5:  ldloc.1
+        IL_00f6:  isinst     ""System.Exception""
+        IL_00fb:  stloc.s    V_5
+        IL_00fd:  ldloc.s    V_5
+        IL_00ff:  brtrue.s   IL_0103
+        IL_0101:  ldloc.1
+        IL_0102:  throw
+        IL_0103:  ldloc.s    V_5
+        IL_0105:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+        IL_010a:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+        IL_010f:  nop
+        IL_0110:  ldarg.0
+        IL_0111:  ldfld      ""int C2.<Main>d__0.<>s__7""
+        IL_0116:  pop
+        IL_0117:  ldarg.0
+        IL_0118:  ldnull
+        IL_0119:  stfld      ""object C2.<Main>d__0.<>s__6""
+        IL_011e:  nop
+        IL_011f:  ldarg.0
+        IL_0120:  ldnull
+        IL_0121:  stfld      ""C1 C2.<Main>d__0.<x>5__5""
+        IL_0126:  leave.s    IL_0139
+      }
+      catch object
+      {
+        IL_0128:  stloc.1
+        IL_0129:  ldarg.0
+        IL_012a:  ldloc.1
+        IL_012b:  stfld      ""object C2.<Main>d__0.<>s__3""
+        IL_0130:  ldarg.0
+        IL_0131:  ldc.i4.1
+        IL_0132:  stfld      ""int C2.<Main>d__0.<>s__4""
+        IL_0137:  leave.s    IL_0139
+      }
+      IL_0139:  ldarg.0
+      IL_013a:  ldfld      ""int C2.<Main>d__0.<>s__4""
+      IL_013f:  stloc.s    V_6
+      IL_0141:  ldloc.s    V_6
+      IL_0143:  ldc.i4.1
+      IL_0144:  beq.s      IL_014b
+      IL_0146:  br         IL_022d
+      IL_014b:  nop
+      IL_014c:  ldarg.0
+      IL_014d:  ldstr      ""Catch""
+      IL_0152:  newobj     ""C1..ctor(string)""
+      IL_0157:  stfld      ""C1 C2.<Main>d__0.<x>5__8""
+      IL_015c:  ldarg.0
+      IL_015d:  ldnull
+      IL_015e:  stfld      ""object C2.<Main>d__0.<>s__9""
+      IL_0163:  ldarg.0
+      IL_0164:  ldc.i4.0
+      IL_0165:  stfld      ""int C2.<Main>d__0.<>s__10""
+      .try
+      {
+        IL_016a:  leave.s    IL_0178
+      }
+      catch object
+      {
+        IL_016c:  stloc.s    V_7
+        IL_016e:  ldarg.0
+        IL_016f:  ldloc.s    V_7
+        IL_0171:  stfld      ""object C2.<Main>d__0.<>s__9""
+        IL_0176:  leave.s    IL_0178
+      }
+      IL_0178:  ldarg.0
+      IL_0179:  ldfld      ""C1 C2.<Main>d__0.<x>5__8""
+      IL_017e:  brfalse.s  IL_01ec
+      IL_0180:  ldarg.0
+      IL_0181:  ldfld      ""C1 C2.<Main>d__0.<x>5__8""
+      IL_0186:  callvirt   ""System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()""
+      IL_018b:  stloc.3
+      IL_018c:  ldloca.s   V_3
+      IL_018e:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+      IL_0193:  stloc.s    V_8
+      IL_0195:  ldloca.s   V_8
+      IL_0197:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+      IL_019c:  brtrue.s   IL_01e4
+      IL_019e:  ldarg.0
+      IL_019f:  ldc.i4.1
+      IL_01a0:  dup
+      IL_01a1:  stloc.0
+      IL_01a2:  stfld      ""int C2.<Main>d__0.<>1__state""
+      IL_01a7:  ldarg.0
+      IL_01a8:  ldloc.s    V_8
+      IL_01aa:  stfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+      IL_01af:  ldarg.0
+      IL_01b0:  stloc.s    V_4
+      IL_01b2:  ldarg.0
+      IL_01b3:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C2.<Main>d__0.<>t__builder""
+      IL_01b8:  ldloca.s   V_8
+      IL_01ba:  ldloca.s   V_4
+      IL_01bc:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.ValueTaskAwaiter, C2.<Main>d__0>(ref System.Runtime.CompilerServices.ValueTaskAwaiter, ref C2.<Main>d__0)""
+      IL_01c1:  nop
+      IL_01c2:  leave      IL_0389
+      IL_01c7:  ldarg.0
+      IL_01c8:  ldfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+      IL_01cd:  stloc.s    V_8
+      IL_01cf:  ldarg.0
+      IL_01d0:  ldflda     ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+      IL_01d5:  initobj    ""System.Runtime.CompilerServices.ValueTaskAwaiter""
+      IL_01db:  ldarg.0
+      IL_01dc:  ldc.i4.m1
+      IL_01dd:  dup
+      IL_01de:  stloc.0
+      IL_01df:  stfld      ""int C2.<Main>d__0.<>1__state""
+      IL_01e4:  ldloca.s   V_8
+      IL_01e6:  call       ""void System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult()""
+      IL_01eb:  nop
+      IL_01ec:  ldarg.0
+      IL_01ed:  ldfld      ""object C2.<Main>d__0.<>s__9""
+      IL_01f2:  stloc.s    V_7
+      IL_01f4:  ldloc.s    V_7
+      IL_01f6:  brfalse.s  IL_0215
+      IL_01f8:  ldloc.s    V_7
+      IL_01fa:  isinst     ""System.Exception""
+      IL_01ff:  stloc.s    V_5
+      IL_0201:  ldloc.s    V_5
+      IL_0203:  brtrue.s   IL_0208
+      IL_0205:  ldloc.s    V_7
+      IL_0207:  throw
+      IL_0208:  ldloc.s    V_5
+      IL_020a:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+      IL_020f:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+      IL_0214:  nop
+      IL_0215:  ldarg.0
+      IL_0216:  ldfld      ""int C2.<Main>d__0.<>s__10""
+      IL_021b:  pop
+      IL_021c:  ldarg.0
+      IL_021d:  ldnull
+      IL_021e:  stfld      ""object C2.<Main>d__0.<>s__9""
+      IL_0223:  nop
+      IL_0224:  ldarg.0
+      IL_0225:  ldnull
+      IL_0226:  stfld      ""C1 C2.<Main>d__0.<x>5__8""
+      IL_022b:  br.s       IL_022d
+      IL_022d:  ldarg.0
+      IL_022e:  ldnull
+      IL_022f:  stfld      ""object C2.<Main>d__0.<>s__3""
+      IL_0234:  leave.s    IL_0242
+    }
+    catch object
+    {
+      IL_0236:  stloc.s    V_7
+      IL_0238:  ldarg.0
+      IL_0239:  ldloc.s    V_7
+      IL_023b:  stfld      ""object C2.<Main>d__0.<>s__1""
+      IL_0240:  leave.s    IL_0242
+    }
+    IL_0242:  nop
+    IL_0243:  ldarg.0
+    IL_0244:  ldstr      ""Finally""
+    IL_0249:  newobj     ""C1..ctor(string)""
+    IL_024e:  stfld      ""C1 C2.<Main>d__0.<x>5__11""
+    IL_0253:  ldarg.0
+    IL_0254:  ldnull
+    IL_0255:  stfld      ""object C2.<Main>d__0.<>s__12""
+    IL_025a:  ldarg.0
+    IL_025b:  ldc.i4.0
+    IL_025c:  stfld      ""int C2.<Main>d__0.<>s__13""
+    .try
+    {
+      IL_0261:  leave.s    IL_026f
+    }
+    catch object
+    {
+      IL_0263:  stloc.s    V_7
+      IL_0265:  ldarg.0
+      IL_0266:  ldloc.s    V_7
+      IL_0268:  stfld      ""object C2.<Main>d__0.<>s__12""
+      IL_026d:  leave.s    IL_026f
+    }
+    IL_026f:  ldarg.0
+    IL_0270:  ldfld      ""C1 C2.<Main>d__0.<x>5__11""
+    IL_0275:  brfalse.s  IL_02e3
+    IL_0277:  ldarg.0
+    IL_0278:  ldfld      ""C1 C2.<Main>d__0.<x>5__11""
+    IL_027d:  callvirt   ""System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()""
+    IL_0282:  stloc.3
+    IL_0283:  ldloca.s   V_3
+    IL_0285:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+    IL_028a:  stloc.s    V_9
+    IL_028c:  ldloca.s   V_9
+    IL_028e:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+    IL_0293:  brtrue.s   IL_02db
+    IL_0295:  ldarg.0
+    IL_0296:  ldc.i4.2
+    IL_0297:  dup
+    IL_0298:  stloc.0
+    IL_0299:  stfld      ""int C2.<Main>d__0.<>1__state""
+    IL_029e:  ldarg.0
+    IL_029f:  ldloc.s    V_9
+    IL_02a1:  stfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+    IL_02a6:  ldarg.0
+    IL_02a7:  stloc.s    V_4
+    IL_02a9:  ldarg.0
+    IL_02aa:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C2.<Main>d__0.<>t__builder""
+    IL_02af:  ldloca.s   V_9
+    IL_02b1:  ldloca.s   V_4
+    IL_02b3:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.ValueTaskAwaiter, C2.<Main>d__0>(ref System.Runtime.CompilerServices.ValueTaskAwaiter, ref C2.<Main>d__0)""
+    IL_02b8:  nop
+    IL_02b9:  leave      IL_0389
+    IL_02be:  ldarg.0
+    IL_02bf:  ldfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+    IL_02c4:  stloc.s    V_9
+    IL_02c6:  ldarg.0
+    IL_02c7:  ldflda     ""System.Runtime.CompilerServices.ValueTaskAwaiter C2.<Main>d__0.<>u__1""
+    IL_02cc:  initobj    ""System.Runtime.CompilerServices.ValueTaskAwaiter""
+    IL_02d2:  ldarg.0
+    IL_02d3:  ldc.i4.m1
+    IL_02d4:  dup
+    IL_02d5:  stloc.0
+    IL_02d6:  stfld      ""int C2.<Main>d__0.<>1__state""
+    IL_02db:  ldloca.s   V_9
+    IL_02dd:  call       ""void System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult()""
+    IL_02e2:  nop
+    IL_02e3:  ldarg.0
+    IL_02e4:  ldfld      ""object C2.<Main>d__0.<>s__12""
+    IL_02e9:  stloc.s    V_7
+    IL_02eb:  ldloc.s    V_7
+    IL_02ed:  brfalse.s  IL_030c
+    IL_02ef:  ldloc.s    V_7
+    IL_02f1:  isinst     ""System.Exception""
+    IL_02f6:  stloc.s    V_5
+    IL_02f8:  ldloc.s    V_5
+    IL_02fa:  brtrue.s   IL_02ff
+    IL_02fc:  ldloc.s    V_7
+    IL_02fe:  throw
+    IL_02ff:  ldloc.s    V_5
+    IL_0301:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+    IL_0306:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+    IL_030b:  nop
+    IL_030c:  ldarg.0
+    IL_030d:  ldfld      ""int C2.<Main>d__0.<>s__13""
+    IL_0312:  pop
+    IL_0313:  ldarg.0
+    IL_0314:  ldnull
+    IL_0315:  stfld      ""object C2.<Main>d__0.<>s__12""
+    IL_031a:  nop
+    IL_031b:  ldarg.0
+    IL_031c:  ldnull
+    IL_031d:  stfld      ""C1 C2.<Main>d__0.<x>5__11""
+    IL_0322:  ldarg.0
+    IL_0323:  ldfld      ""object C2.<Main>d__0.<>s__1""
+    IL_0328:  stloc.s    V_7
+    IL_032a:  ldloc.s    V_7
+    IL_032c:  brfalse.s  IL_034b
+    IL_032e:  ldloc.s    V_7
+    IL_0330:  isinst     ""System.Exception""
+    IL_0335:  stloc.s    V_5
+    IL_0337:  ldloc.s    V_5
+    IL_0339:  brtrue.s   IL_033e
+    IL_033b:  ldloc.s    V_7
+    IL_033d:  throw
+    IL_033e:  ldloc.s    V_5
+    IL_0340:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+    IL_0345:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+    IL_034a:  nop
+    IL_034b:  ldarg.0
+    IL_034c:  ldfld      ""int C2.<Main>d__0.<>s__2""
+    IL_0351:  pop
+    IL_0352:  ldarg.0
+    IL_0353:  ldnull
+    IL_0354:  stfld      ""object C2.<Main>d__0.<>s__1""
+    IL_0359:  leave.s    IL_0375
+  }
+  catch System.Exception
+  {
+    IL_035b:  stloc.s    V_5
+    IL_035d:  ldarg.0
+    IL_035e:  ldc.i4.s   -2
+    IL_0360:  stfld      ""int C2.<Main>d__0.<>1__state""
+    IL_0365:  ldarg.0
+    IL_0366:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C2.<Main>d__0.<>t__builder""
+    IL_036b:  ldloc.s    V_5
+    IL_036d:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception)""
+    IL_0372:  nop
+    IL_0373:  leave.s    IL_0389
+  }
+  IL_0375:  ldarg.0
+  IL_0376:  ldc.i4.s   -2
+  IL_0378:  stfld      ""int C2.<Main>d__0.<>1__state""
+  IL_037d:  ldarg.0
+  IL_037e:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C2.<Main>d__0.<>t__builder""
+  IL_0383:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult()""
+  IL_0388:  nop
+  IL_0389:  ret
+}
+");
+        }
+
         [Fact]
         public void UsingDeclarationUsingPatternIntersectionEmitTest()
         {
@@ -1089,5 +1572,336 @@ static async Task Main()
             CompileAndVerify(source, expectedOutput: "Dispose; ");
         }
 
+        [Fact]
+        public void UsingDeclarationAsync()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    public ValueTask DisposeAsync() 
+    { 
+        Console.WriteLine(""Dispose async"");
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c = new C1();
+    }
+}";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: "Dispose async");
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncExplicit()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    ValueTask IAsyncDisposable.DisposeAsync() 
+    { 
+        Console.WriteLine(""Dispose async"");
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c = new C1();
+    }
+}";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: "Dispose async");
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncPattern()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1
+{
+    public C1() 
+    {
+        Console.Write(""Created C1; "");
+    }
+
+    public Task DisposeAsync() 
+    { 
+        System.Console.Write(""Dispose async; "");
+        return Task.CompletedTask;
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c = new C1();
+        Console.Write(""After declaration; "");
+    }
+}";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: "Created C1; After declaration; Dispose async; ");
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncWithMultipleDeclarations()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    string text;
+
+    public C1(string text)
+    {
+        this.text = text;
+        Console.WriteLine($""Created {text}"");
+    }
+
+    public ValueTask DisposeAsync() 
+    { 
+        Console.WriteLine($""Dispose async {text}"");
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c = new C1(""first""), c2 = new C1(""second""), c3 = new C1(""third"");
+        Console.WriteLine(""After declarations"");
+    }
+}";
+            string expectedOutput = @"
+Created first
+Created second
+Created third
+After declarations
+Dispose async third
+Dispose async second
+Dispose async first
+";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncWithMultipleInARow()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    string text;
+
+    public C1(string text)
+    {
+        this.text = text;
+        Console.WriteLine($""Created {text}"");
+    }
+
+    public ValueTask DisposeAsync() 
+    { 
+        Console.WriteLine($""Dispose async {text}"");
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c1 = new C1(""first"");
+        await using C1 c2 = new C1(""second"");
+        await using C1 c3 = new C1(""third"");
+        Console.WriteLine(""After declarations"");
+    }
+}";
+            string expectedOutput = @"
+Created first
+Created second
+Created third
+After declarations
+Dispose async third
+Dispose async second
+Dispose async first
+";
+
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncPatternWithTaskLikeReturnTest()
+        {
+            var source = @"
+using System;
+using System.Runtime.CompilerServices;
+class C1
+{
+    public C1() { }
+    public MyTask DisposeAsync() {  Console.Write(""Dispose Async; ""); return new MyTask(); }
+}
+
+[AsyncMethodBuilder(typeof(MyTaskMethodBuilder))]
+struct MyTask
+{
+    internal Awaiter GetAwaiter() => new Awaiter();
+    internal class Awaiter : INotifyCompletion
+    {
+        public void OnCompleted(Action a) { }
+        internal bool IsCompleted => true;
+        internal void GetResult() { }
+    }
+}
+
+struct MyTaskMethodBuilder
+{
+    private MyTask _task;
+    public static MyTaskMethodBuilder Create() => new MyTaskMethodBuilder(new MyTask());
+    internal MyTaskMethodBuilder(MyTask task)
+    {
+        _task = task;
+    }
+    public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+    {
+        stateMachine.MoveNext();
+    }
+    public void SetException(Exception e) { }
+    public void SetResult() { }
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+    public MyTask Task => _task;
+}
+
+class C2
+{
+    static async System.Threading.Tasks.Task Main()
+    {
+        await using C1 c = new C1();
+    }
+}";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: "Dispose Async; ");
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncPatternExtensionMethod()
+        {
+            var source = @"
+using System.Threading.Tasks;
+class C1
+{
+}
+
+static class C2
+{
+    public static Task DisposeAsync(this C1 c1) 
+    { 
+        System.Console.WriteLine(""Dispose async"");
+        return Task.CompletedTask;
+    }
+}
+
+class C3
+{
+    static async Task Main()
+    {
+        await using C1 c = new C1();
+    }
+}";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: "Dispose async");
+        }
+
+        [Fact]
+        public void UsingDeclarationWithNull()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IDisposable
+{
+    public void Dispose() 
+    {
+        Console.Write(""Dispose; "");
+    }
+}
+
+ class C2 : IAsyncDisposable
+{
+    public ValueTask DisposeAsync() 
+    { 
+        System.Console.WriteLine(""Dispose async"");
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C3
+{
+    static async Task Main()
+    {
+        using C1 c1 = null; 
+        await using C2 c2 = null;
+        Console.Write(""After declarations; "");
+    }
+}";
+            var compilation = CreateCompilationWithTasksExtensions(source + _asyncDisposable, options: TestOptions.DebugExe).VerifyDiagnostics();
+
+            CompileAndVerify(compilation, expectedOutput: "After declarations; ");
+        }
+
+        [Fact]
+        public void UsingDeclarationAsyncMissingValueTask()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    public ValueTask DisposeAsync() 
+    { 
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c1 = new C1();
+    }
+}";
+
+            var comp = CreateCompilationWithTasksExtensions(source + _asyncDisposable);
+            comp.MakeTypeMissing(WellKnownType.System_Threading_Tasks_ValueTask);
+            comp.VerifyDiagnostics(
+                // (16,9): error CS0518: Predefined type 'System.Threading.Tasks.ValueTask' is not defined or imported
+                //         await using C1 c1 = new C1();
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "await").WithArguments("System.Threading.Tasks.ValueTask").WithLocation(16, 9)
+                );
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs
index e8dc71aae10fb..f7778c403ee4b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs
@@ -11,6 +11,16 @@ namespace Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests.Semantics
     /// </summary>
     public class UsingDeclarationTests : CompilingTestBase
     {
+        //PROTOTYPE: remove this and use CSharpTestBase.AsyncStreamTypes when merged
+        private const string _asyncDisposable = @"
+namespace System
+{
+    public interface IAsyncDisposable
+    {
+        System.Threading.Tasks.ValueTask DisposeAsync();
+    }
+}";
+
         [Fact]
         public void UsingVariableIsNotReportedAsUnused()
         {
@@ -620,5 +630,108 @@ static async Task Main()
 
             CompileAndVerify(compilation, expectedOutput: "after c1; after c2; Dispose c2; Dispose c1; ");
         }
+
+        [Fact]
+        public void UsingDeclarationsWithLangVer7_3()
+        {
+            var source = @"
+using System;
+class C
+{
+    static void Main()
+    {
+        using IDisposable x = null;
+    }
+}
+";
+            CreateCompilation(source,  parseOptions: TestOptions.Regular7_3).VerifyDiagnostics(
+                // (7,9): error CS8370: Feature 'using declarations' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //         using IDisposable x = null;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "using").WithArguments("using declarations", "8.0").WithLocation(7, 9)
+                );
+        }
+
+        [Fact]
+        public void AwaitUsingDeclarationsWithLangVer7_3()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C
+{
+    static async Task Main()
+    {
+        await using IAsyncDisposable x = null;
+    }
+}
+";
+            CreateCompilationWithTasksExtensions(source + _asyncDisposable, parseOptions: TestOptions.Regular7_3).VerifyDiagnostics(
+                // (8,9): error CS8370: Feature 'async streams' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //         await using IAsyncDisposable x = null;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "await").WithArguments("async streams", "8.0").WithLocation(8, 9),
+                // (8,15): error CS8370: Feature 'using declarations' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //         await using IAsyncDisposable x = null;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "using").WithArguments("using declarations", "8.0").WithLocation(8, 15)
+                );
+        }
+
+        [Fact]
+        public void UsingDeclarationsWithObsoleteTypes()
+        {
+            var source = @"
+using System;
+
+[Obsolete]
+class C1 : IDisposable
+{
+    [Obsolete]
+    public void Dispose()  
+    {
+    }
+}
+
+class C2 : IDisposable
+{
+    [Obsolete]
+    public void Dispose()  
+    {
+    }
+}
+
+ref struct S3
+{
+    [Obsolete]
+    public void Dispose()
+    {
+    }
+}
+
+class C4
+{
+    static void Main()
+    {
+        // c1 is obsolete
+        using C1 c1 = new C1();
+
+        // no warning, we don't warn on dispose being obsolete because it comes through interface
+        using C2 c2 = new C2();
+    
+        // warning, we're calling the pattern based obsolete method for the ref struct
+        using S3 S3 = new S3();
+    }
+}
+";
+            CreateCompilation(source).VerifyDiagnostics(
+                // (34,15): warning CS0612: 'C1' is obsolete
+                //         using C1 c1 = new C1();
+                Diagnostic(ErrorCode.WRN_DeprecatedSymbol, "C1").WithArguments("C1").WithLocation(34, 15),
+                // (34,27): warning CS0612: 'C1' is obsolete
+                //         using C1 c1 = new C1();
+                Diagnostic(ErrorCode.WRN_DeprecatedSymbol, "C1").WithArguments("C1").WithLocation(34, 27),
+                // (40,15): warning CS0612: 'S3.Dispose()' is obsolete
+                //         using S3 S3 = new S3();
+                Diagnostic(ErrorCode.WRN_DeprecatedSymbol, "S3 S3 = new S3()").WithArguments("S3.Dispose()").WithLocation(40, 15)
+                );
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
index d8467325e7dae..fda733023c02e 100644
--- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
@@ -431,7 +431,7 @@ private static Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LocalFunction
         
         private static Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LocalDeclarationStatementSyntax GenerateLocalDeclarationStatement()
         {
-            return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LocalDeclarationStatement(null, new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxToken>(), GenerateVariableDeclaration(), Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+            return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LocalDeclarationStatement(null, null, new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxToken>(), GenerateVariableDeclaration(), Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Token(SyntaxKind.SemicolonToken));
         }
         
         private static Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax GenerateVariableDeclaration()
@@ -2049,6 +2049,7 @@ public void TestLocalDeclarationStatementFactoryAndProperties()
         {
             var node = GenerateLocalDeclarationStatement();
             
+            Assert.Null(node.AwaitKeyword);
             Assert.Null(node.UsingKeyword);
             Assert.NotNull(node.Modifiers);
             Assert.NotNull(node.Declaration);
@@ -9489,7 +9490,7 @@ private static LocalFunctionStatementSyntax GenerateLocalFunctionStatement()
         
         private static LocalDeclarationStatementSyntax GenerateLocalDeclarationStatement()
         {
-            return SyntaxFactory.LocalDeclarationStatement(default(SyntaxToken), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+            return SyntaxFactory.LocalDeclarationStatement(default(SyntaxToken), default(SyntaxToken), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken));
         }
         
         private static VariableDeclarationSyntax GenerateVariableDeclaration()
@@ -11107,11 +11108,12 @@ public void TestLocalDeclarationStatementFactoryAndProperties()
         {
             var node = GenerateLocalDeclarationStatement();
             
+            Assert.Equal(SyntaxKind.None, node.AwaitKeyword.Kind());
             Assert.Equal(SyntaxKind.None, node.UsingKeyword.Kind());
             Assert.NotNull(node.Modifiers);
             Assert.NotNull(node.Declaration);
             Assert.Equal(SyntaxKind.SemicolonToken, node.SemicolonToken.Kind());
-            var newNode = node.WithUsingKeyword(node.UsingKeyword).WithModifiers(node.Modifiers).WithDeclaration(node.Declaration).WithSemicolonToken(node.SemicolonToken);
+            var newNode = node.WithAwaitKeyword(node.AwaitKeyword).WithUsingKeyword(node.UsingKeyword).WithModifiers(node.Modifiers).WithDeclaration(node.Declaration).WithSemicolonToken(node.SemicolonToken);
             Assert.Equal(node, newNode);
         }
         
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/AsyncStreamsParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/AsyncStreamsParsingTests.cs
index f613a6c7b42ff..0466d0d9c32d5 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/AsyncStreamsParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/AsyncStreamsParsingTests.cs
@@ -287,29 +287,38 @@ async void M()
                         N(SyntaxKind.Block);
                         {
                             N(SyntaxKind.OpenBraceToken);
-                            N(SyntaxKind.UsingStatement);
+                            N(SyntaxKind.LocalDeclarationStatement);
                             {
                                 N(SyntaxKind.UsingKeyword);
-                                M(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.AwaitExpression);
+                                N(SyntaxKind.VariableDeclaration);
                                 {
-                                    N(SyntaxKind.AwaitKeyword);
-                                    N(SyntaxKind.ParenthesizedExpression);
+                                    N(SyntaxKind.IdentifierName);
                                     {
-                                        N(SyntaxKind.OpenParenToken);
-                                        N(SyntaxKind.ThisExpression);
+                                        N(SyntaxKind.IdentifierToken, "await");
+                                    }
+                                    N(SyntaxKind.VariableDeclarator);
+                                    {
+                                        M(SyntaxKind.IdentifierToken);
+                                        N(SyntaxKind.BracketedArgumentList);
                                         {
-                                            N(SyntaxKind.ThisKeyword);
+                                            M(SyntaxKind.OpenBracketToken);
+                                            N(SyntaxKind.Argument);
+                                            {
+                                                N(SyntaxKind.ThisExpression);
+                                                {
+                                                    N(SyntaxKind.ThisKeyword);
+                                                }
+                                            }
+                                            M(SyntaxKind.CloseBracketToken);
                                         }
-                                        N(SyntaxKind.CloseParenToken);
                                     }
                                 }
-                                M(SyntaxKind.CloseParenToken);
-                                N(SyntaxKind.Block);
-                                {
-                                    N(SyntaxKind.OpenBraceToken);
-                                    N(SyntaxKind.CloseBraceToken);
-                                }
+                                M(SyntaxKind.SemicolonToken);
+                            }
+                            N(SyntaxKind.Block);
+                            {
+                                N(SyntaxKind.OpenBraceToken);
+                                N(SyntaxKind.CloseBraceToken);
                             }
                             N(SyntaxKind.CloseBraceToken);
                         }
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs
index fa62a5f4e41d5..4009893d3989e 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs
@@ -2354,7 +2354,7 @@ public void TestUsingWithDeclaration()
         public void TestUsingVarWithDeclaration()
         {
             var text = "using T a = b;";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
@@ -2382,7 +2382,7 @@ public void TestUsingVarWithDeclaration()
         [Fact]
         public void TestUsingVarWithDeclarationTree()
         {
-            UsingStatement(@"using T a = b;");
+            UsingStatement(@"using T a = b;", options: TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2449,7 +2449,7 @@ public void TestUsingWithVarDeclaration()
         public void TestUsingVarWithVarDeclaration()
         {
             var text = "using var a = b;";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
@@ -2478,9 +2478,103 @@ public void TestUsingVarWithVarDeclaration()
         [Fact]
         public void TestUsingVarWithVarDeclarationTree()
         {
-            UsingStatement(@"using var a = b;");
+            UsingStatement(@"using var a = b;", options: TestOptions.Regular8);
+            N(SyntaxKind.LocalDeclarationStatement);
+            {
+                N(SyntaxKind.UsingKeyword);
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName, "var");
+                    {
+                        N(SyntaxKind.IdentifierToken, "var");
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "a");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.IdentifierName, "b");
+                            {
+                                N(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+        }
+
+        [Fact]
+        public void TestAwaitUsingVarWithDeclarationTree()
+        {
+            UsingStatement(@"await using T a = b;", TestOptions.Regular8);
+            N(SyntaxKind.LocalDeclarationStatement);
+            {
+                N(SyntaxKind.AwaitKeyword);
+                N(SyntaxKind.UsingKeyword);
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName, "T");
+                    {
+                        N(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "a");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.IdentifierName, "b");
+                            {
+                                N(SyntaxKind.IdentifierToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+        }
+
+        [Fact]
+        public void TestAwaitUsingWithVarDeclaration()
+        {
+            var text = "await using var a = b;";
+            var statement = this.ParseStatement(text, 0, TestOptions.Regular8);
+
+            Assert.NotNull(statement);
+            Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
+            Assert.Equal(text, statement.ToString());
+            Assert.Equal(0, statement.Errors().Length);
+
+            var us = (LocalDeclarationStatementSyntax)statement;
+            Assert.NotNull(us.AwaitKeyword);
+            Assert.Equal(SyntaxKind.AwaitKeyword, us.AwaitKeyword.ContextualKind());
+            Assert.NotNull(us.UsingKeyword);
+            Assert.Equal(SyntaxKind.UsingKeyword, us.UsingKeyword.Kind());
+
+            Assert.NotNull(us.Declaration);
+            Assert.NotNull(us.Declaration.Type);
+            Assert.Equal("var", us.Declaration.Type.ToString());
+            Assert.Equal(SyntaxKind.IdentifierName, us.Declaration.Type.Kind());
+            Assert.Equal(SyntaxKind.IdentifierToken, ((IdentifierNameSyntax)us.Declaration.Type).Identifier.Kind());
+            Assert.Equal(1, us.Declaration.Variables.Count);
+            Assert.NotNull(us.Declaration.Variables[0].Identifier);
+            Assert.Equal("a", us.Declaration.Variables[0].Identifier.ToString());
+            Assert.Null(us.Declaration.Variables[0].ArgumentList);
+            Assert.NotNull(us.Declaration.Variables[0].Initializer);
+            Assert.NotNull(us.Declaration.Variables[0].Initializer.EqualsToken);
+            Assert.NotNull(us.Declaration.Variables[0].Initializer.Value);
+            Assert.Equal("b", us.Declaration.Variables[0].Initializer.Value.ToString());
+        }
+
+        [Fact]
+        public void TestAwaitUsingVarWithVarDeclarationTree()
+        {
+            UsingStatement(@"await using var a = b;", TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
+                N(SyntaxKind.AwaitKeyword);
                 N(SyntaxKind.UsingKeyword);
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2505,6 +2599,109 @@ public void TestUsingVarWithVarDeclarationTree()
             }
         }
 
+        [Fact, WorkItem(30565, "https://github.com/dotnet/roslyn/issues/30565")]
+        public void AwaitUsingVarWithVarDecl_Reversed()
+        {
+            UsingTree(@"
+class C
+{
+    async void M()
+    {
+        using await var x = null;
+    }
+}
+");
+            N(SyntaxKind.CompilationUnit);
+            {
+                N(SyntaxKind.ClassDeclaration);
+                {
+                    N(SyntaxKind.ClassKeyword);
+                    N(SyntaxKind.IdentifierToken, "C");
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.MethodDeclaration);
+                    {
+                        N(SyntaxKind.AsyncKeyword);
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.VoidKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "M");
+                        N(SyntaxKind.ParameterList);
+                        {
+                            N(SyntaxKind.OpenParenToken);
+                            N(SyntaxKind.CloseParenToken);
+                        }
+                        N(SyntaxKind.Block);
+                        {
+                            N(SyntaxKind.OpenBraceToken);
+                            N(SyntaxKind.LocalDeclarationStatement);
+                            {
+                                N(SyntaxKind.UsingKeyword);
+                                N(SyntaxKind.VariableDeclaration);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "await");
+                                    }
+                                    N(SyntaxKind.VariableDeclarator);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "var");
+                                    }
+                                }
+                                M(SyntaxKind.SemicolonToken);
+                            }
+                            N(SyntaxKind.ExpressionStatement);
+                            {
+                                N(SyntaxKind.SimpleAssignmentExpression);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                    }
+                                    N(SyntaxKind.EqualsToken);
+                                    N(SyntaxKind.NullLiteralExpression);
+                                    {
+                                        N(SyntaxKind.NullKeyword);
+                                    }
+                                }
+                                N(SyntaxKind.SemicolonToken);
+                            }
+                            N(SyntaxKind.CloseBraceToken);
+                        }
+                    }
+                    N(SyntaxKind.CloseBraceToken);
+                }
+                N(SyntaxKind.EndOfFileToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestAwaitUsingVarWithVarAndNoUsingDeclarationTree()
+        {
+            UsingStatement(@"await var a = b;", TestOptions.Regular8, expectedErrors:
+                // (1,11): error CS1003: Syntax error, ',' expected
+                // await var a = b;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "a").WithArguments(",", "").WithLocation(1, 11)
+            );
+            N(SyntaxKind.LocalDeclarationStatement);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "await");
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "var");
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
         [Fact]
         public void TestUsingWithDeclarationWithMultipleVariables()
         {
@@ -2553,7 +2750,7 @@ public void TestUsingWithDeclarationWithMultipleVariables()
         public void TestUsingVarWithDeclarationWithMultipleVariables()
         {
             var text = "using T a = b, c = d;";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
@@ -2590,7 +2787,7 @@ public void TestUsingVarWithDeclarationWithMultipleVariables()
         [Fact]
         public void TestUsingVarWithDeclarationMultipleVariablesTree()
         {
-            UsingStatement(@"using T a = b, c = d;");
+            UsingStatement(@"using T a = b, c = d;", options: TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2656,7 +2853,7 @@ public void TestUsingSpecialCase1()
         public void TestUsingVarSpecialCase1()
         {
             var text = "using var x = f ? a : b;";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
@@ -2673,7 +2870,7 @@ public void TestUsingVarSpecialCase1()
         [Fact]
         public void TestUsingVarSpecialCase1Tree()
         {
-            UsingStatement(@"using var x = f ? a : b;");
+            UsingStatement(@"using var x = f ? a : b;", options: TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2717,7 +2914,7 @@ public void TestUsingVarSpecialCase1Tree()
         public void TestUsingSpecialCase2()
         {
             var text = "using (f ? x = a) { }";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.UsingStatement, statement.Kind());
@@ -2739,7 +2936,7 @@ public void TestUsingSpecialCase2()
         public void TestUsingVarSpecialCase2()
         {
             var text = "using f ? x = a;";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
@@ -2756,7 +2953,7 @@ public void TestUsingVarSpecialCase2()
         [Fact]
         public void TestUsingVarSpecialCase2Tree()
         {
-            UsingStatement(@"using f ? x = a;");
+            UsingStatement(@"using f ? x = a;", options: TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2811,7 +3008,7 @@ public void TestUsingSpecialCase3()
         public void TestUsingVarSpecialCase3()
         {
             var text = "using f ? x, y;";
-            var statement = this.ParseStatement(text);
+            var statement = this.ParseStatement(text, options: TestOptions.Regular8);
 
             Assert.NotNull(statement);
             Assert.Equal(SyntaxKind.LocalDeclarationStatement, statement.Kind());
@@ -2828,7 +3025,7 @@ public void TestUsingVarSpecialCase3()
         [Fact]
         public void TestUsingVarSpecialCase3Tree()
         {
-            UsingStatement("using f? x, y;");
+            UsingStatement("using f? x, y;", options: TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2859,7 +3056,7 @@ public void TestUsingVarSpecialCase3Tree()
         [Fact]
         public void TestUsingVarRefTree()
         {
-            UsingStatement("using ref int x = ref y;");
+            UsingStatement("using ref int x = ref y;", TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2897,7 +3094,7 @@ public void TestUsingVarRefTree()
         [Fact]
         public void TestUsingVarRefReadonlyTree()
         {
-            UsingStatement("using ref readonly int x = ref y;", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_2));
+            UsingStatement("using ref readonly int x = ref y;", TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2936,7 +3133,7 @@ public void TestUsingVarRefReadonlyTree()
         [Fact]
         public void TestUsingVarRefVarTree()
         {
-            UsingStatement("using ref var x = ref y;", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_2));
+            UsingStatement("using ref var x = ref y;", TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -2974,7 +3171,7 @@ public void TestUsingVarRefVarTree()
         [Fact]
         public void TestUsingVarRefVarIsYTree()
         {
-            UsingStatement("using ref var x = y;", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_2));
+            UsingStatement("using ref var x = y;", TestOptions.Regular8);
             N(SyntaxKind.LocalDeclarationStatement);
             {
                 N(SyntaxKind.UsingKeyword);
@@ -3008,7 +3205,7 @@ public void TestUsingVarRefVarIsYTree()
         [Fact]
         public void TestUsingVarReadonlyMultipleDeclarations()
         {
-            UsingStatement("using readonly var x, y = ref z;", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_2),
+            UsingStatement("using readonly var x, y = ref z;", TestOptions.Regular8,
                 // (1,7): error CS0106: The modifier 'readonly' is not valid for this item
                 // using readonly var x, y = ref z;
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "readonly").WithArguments("readonly").WithLocation(1,7));
diff --git a/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/AsyncAwaitHighlighter.cs b/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/AsyncAwaitHighlighter.cs
index b4b834dafda56..9c446aa9fe289 100644
--- a/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/AsyncAwaitHighlighter.cs
+++ b/src/EditorFeatures/CSharp/Highlighting/KeywordHighlighters/AsyncAwaitHighlighter.cs
@@ -84,6 +84,13 @@ private static void HighlightRelatedKeywords(SyntaxNode node, List<TextSpan> spa
                     }
                     break;
 
+                case LocalDeclarationStatementSyntax localDeclaration:
+                    if(localDeclaration.AwaitKeyword.Kind() == SyntaxKind.AwaitKeyword && localDeclaration.UsingKeyword.Kind() == SyntaxKind.UsingKeyword)
+                    {
+                        spans.Add(localDeclaration.AwaitKeyword.Span);
+                    }
+                    break;
+
                 case CommonForEachStatementSyntax forEachStatement:
                     if (forEachStatement.AwaitKeyword.Kind() == SyntaxKind.AwaitKeyword)
                     {
diff --git a/src/EditorFeatures/CSharpTest/KeywordHighlighting/AwaitHighlighterTests.cs b/src/EditorFeatures/CSharpTest/KeywordHighlighting/AwaitHighlighterTests.cs
index 9a05520357ea2..4bdc7b3273cd3 100644
--- a/src/EditorFeatures/CSharpTest/KeywordHighlighting/AwaitHighlighterTests.cs
+++ b/src/EditorFeatures/CSharpTest/KeywordHighlighting/AwaitHighlighterTests.cs
@@ -202,7 +202,7 @@ private static Task<int> NewMethod()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordHighlighting)]
-        public async Task TestUsingAwait_OnAsync()
+        public async Task TestAwaitUsing_OnAsync()
         {
             await TestAsync(
 @"using System.Threading.Tasks;
@@ -211,13 +211,13 @@ class C
 {
     {|Cursor:[|async|]|} Task M()
     {
-        using [|await|] (var x = new object());
+        [|await|] using (var x = new object());
     }
 }");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordHighlighting)]
-        public async Task TestUsingAwait_OnAwait()
+        public async Task TestAwaitUsing_OnAwait()
         {
             await TestAsync(
 @"using System.Threading.Tasks;
@@ -226,7 +226,37 @@ class C
 {
     [|async|] Task M()
     {
-        using {|Cursor:[|await|]|} (var x = new object());
+        {|Cursor:[|await|]|} using (var x = new object());
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordHighlighting)]
+        public async Task TestAwaitUsingDeclaration_OnAsync()
+        {
+            await TestAsync(
+@"using System.Threading.Tasks;
+
+class C
+{
+    {|Cursor:[|async|]|} Task M()
+    {
+        [|await|] using var x = new object();
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordHighlighting)]
+        public async Task TestAwaitUsingDeclaration_OnAwait()
+        {
+            await TestAsync(
+@"using System.Threading.Tasks;
+
+class C
+{
+    [|async|] Task M()
+    {
+        {|Cursor:[|await|]|} using var x = new object();
     }
 }");
         }