diff --git a/ChangeLog.md b/ChangeLog.md
index 87731d8d20..3735a8f14f 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - [CLI] Bump Roslyn to 4.9.2 ([PR](https://github.com/dotnet/roslynator/pull/1441))
+- Convert `Last()` to `[]` ([RCS1246](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1246)) ([PR](https://github.com/dotnet/roslynator/pull/1436))
 
 ### Fixed
 
diff --git a/src/Analyzers.CodeFixes/CSharp/CodeFixes/OptimizeLinqMethodCallCodeFixProvider.cs b/src/Analyzers.CodeFixes/CSharp/CodeFixes/OptimizeLinqMethodCallCodeFixProvider.cs
index e93a85e216..87c90cec4d 100644
--- a/src/Analyzers.CodeFixes/CSharp/CodeFixes/OptimizeLinqMethodCallCodeFixProvider.cs
+++ b/src/Analyzers.CodeFixes/CSharp/CodeFixes/OptimizeLinqMethodCallCodeFixProvider.cs
@@ -257,6 +257,16 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                             ct => UseElementAccessInsteadOfEnumerableMethodRefactoring.UseElementAccessInsteadOfElementAtAsync(document, invocation, ct),
                             GetEquivalenceKey(diagnostic, "UseElementAccessInsteadOfElementAt"));
 
+                        context.RegisterCodeFix(codeAction, diagnostic);
+                        return;
+                    }
+                case "Last":
+                    {
+                        CodeAction codeAction = CodeAction.Create(
+                            "Use [] instead of calling 'Last'",
+                            ct => UseElementAccessInsteadOfEnumerableMethodRefactoring.UseElementAccessInsteadOfLastAsync(document, invocation, ct),
+                            GetEquivalenceKey(diagnostic, "UseElementAccessInsteadOfLast"));
+
                         context.RegisterCodeFix(codeAction, diagnostic);
                         return;
                     }
diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index 3f23b872b1..e098e4b9fc 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -7277,6 +7277,7 @@ public class C
     <Title>Use element access</Title>
     <DefaultSeverity>Info</DefaultSeverity>
     <IsEnabledByDefault>true</IsEnabledByDefault>
+    <MinLanguageVersion>8.0 for [^1]</MinLanguageVersion>
     <Samples>
       <Sample>
         <Before><![CDATA[list.First()]]></Before>
@@ -7286,6 +7287,10 @@ public class C
         <Before><![CDATA[list.ElementAt(1)]]></Before>
         <After><![CDATA[list[1]]]></After>
       </Sample>
+      <Sample>
+        <Before><![CDATA[list.Last()]]></Before>
+        <After><![CDATA[list[^1]]]></After>
+      </Sample>
     </Samples>
     <Options>
       <Option Identifier="DoNotUseElementAccessWhenExpressionIsInvocation">
diff --git a/src/Analyzers/CSharp/Analysis/InvocationExpressionAnalyzer.cs b/src/Analyzers/CSharp/Analysis/InvocationExpressionAnalyzer.cs
index ddf9bc444a..b8d36460c7 100644
--- a/src/Analyzers/CSharp/Analysis/InvocationExpressionAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analysis/InvocationExpressionAnalyzer.cs
@@ -192,6 +192,23 @@ private static void AnalyzeInvocationExpression(SyntaxNodeAnalysisContext contex
                                 break;
                             }
                         case "Last":
+                            {
+                                if (DiagnosticRules.OptimizeLinqMethodCall.IsEffective(context))
+                                {
+                                    if (!invocationInfo.Expression.IsKind(SyntaxKind.ElementAccessExpression, SyntaxKind.InvocationExpression)
+                                        && UseElementAccessAnalysis.IsFixableLast(invocationInfo, context.SemanticModel, context.CancellationToken))
+                                    {
+                                        DiagnosticHelpers.ReportDiagnostic(
+                                            context,
+                                            DiagnosticRules.UseElementAccess,
+                                            Location.Create(invocation.SyntaxTree, TextSpan.FromBounds(invocationInfo.Name.SpanStart, invocationInfo.ArgumentList.Span.End)));
+                                    }
+
+                                    OptimizeLinqMethodCallAnalysis.AnalyzeWhere(context, invocationInfo);
+                                }
+
+                                break;
+                            }
                         case "LastOrDefault":
                         case "LongCount":
                         case "Single":
diff --git a/src/Common/CSharp/Analysis/UseElementAccessAnalysis.cs b/src/Common/CSharp/Analysis/UseElementAccessAnalysis.cs
index fc64b2ee70..b96ac44334 100644
--- a/src/Common/CSharp/Analysis/UseElementAccessAnalysis.cs
+++ b/src/Common/CSharp/Analysis/UseElementAccessAnalysis.cs
@@ -74,6 +74,9 @@ internal static class UseElementAccessAnalysis
         if (invocationInfo.InvocationExpression.IsParentKind(SyntaxKind.ExpressionStatement))
             return false;
 
+        if (((CSharpCompilation)semanticModel.Compilation).LanguageVersion < LanguageVersion.CSharp8)
+            return false;
+
         IMethodSymbol methodSymbol = semanticModel.GetReducedExtensionMethodInfo(invocationInfo.InvocationExpression, cancellationToken).Symbol;
 
         if (methodSymbol is null)
diff --git a/src/Refactorings/CSharp/Refactorings/UseElementAccessRefactoring.cs b/src/Refactorings/CSharp/Refactorings/UseElementAccessRefactoring.cs
index b490bd2be2..35990154d4 100644
--- a/src/Refactorings/CSharp/Refactorings/UseElementAccessRefactoring.cs
+++ b/src/Refactorings/CSharp/Refactorings/UseElementAccessRefactoring.cs
@@ -50,14 +50,9 @@ public static async Task ComputeRefactoringsAsync(RefactoringContext context, In
                     if (!UseElementAccessAnalysis.IsFixableLast(invocationInfo, semanticModel, context.CancellationToken))
                         break;
 
-                    string propertyName = CSharpUtility.GetCountOrLengthPropertyName(invocationInfo.Expression, semanticModel, context.CancellationToken);
-
-                    if (propertyName is null)
-                        break;
-
                     context.RegisterRefactoring(
                         "Use [] instead of calling 'Last'",
-                        ct => UseElementAccessInsteadOfEnumerableMethodRefactoring.UseElementAccessInsteadOfLastAsync(context.Document, invocation, propertyName, ct),
+                        ct => UseElementAccessInsteadOfEnumerableMethodRefactoring.UseElementAccessInsteadOfLastAsync(context.Document, invocation, ct),
                         RefactoringDescriptors.UseElementAccessInsteadOfLinqMethod);
 
                     break;
diff --git a/src/Tests/Analyzers.Tests/RCS1246UseElementAccessTests.cs b/src/Tests/Analyzers.Tests/RCS1246UseElementAccessTests.cs
index c8c33e869b..8ebbf97d4e 100644
--- a/src/Tests/Analyzers.Tests/RCS1246UseElementAccessTests.cs
+++ b/src/Tests/Analyzers.Tests/RCS1246UseElementAccessTests.cs
@@ -94,6 +94,60 @@ void M()
 ");
     }
 
+    [Theory, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseElementAccess)]
+    [InlineData("((List<object>)x).[|Last()|]", "((List<object>)x)[^1]")]
+    [InlineData("((IList<object>)x).[|Last()|]", "((IList<object>)x)[^1]")]
+    [InlineData("((IReadOnlyList<object>)x).[|Last()|]", "((IReadOnlyList<object>)x)[^1]")]
+    [InlineData("((Collection<object>)x).[|Last()|]", "((Collection<object>)x)[^1]")]
+    [InlineData("((ImmutableArray<object>)x).[|Last()|]", "((ImmutableArray<object>)x)[^1]")]
+    [InlineData("((object[])x).[|Last()|]", "((object[])x)[^1]")]
+    [InlineData("((string)x).[|Last()|]", "((string)x)[^1]")]
+    public async Task Test_UseElementAccessInsteadOfLast(string source, string expected)
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+
+class C
+{
+    void M()
+    {
+        object x = null;
+        var y = [||];
+    }
+}
+", source, expected);
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseElementAccess)]
+    public async Task TestNoDiagnostic_UseElementAccessInsteadOfLast()
+    {
+        await VerifyNoDiagnosticAsync(@"
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+
+class C
+{
+    void M()
+    {
+        object x = null;
+
+        x = ((ICollection<object>)x).Last();
+        x = ((IReadOnlyCollection<object>)x).Last();
+        x = ((IEnumerable<object>)x).Last();
+
+        x = ((Dictionary<object, object>)x).Last();
+    }
+}
+");
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseElementAccess)]
     public async Task TestNoDiagnostic_UseElementAccessInsteadOfFirst()
     {
diff --git a/src/Workspaces.Common/CSharp/Refactorings/UseElementAccessInsteadOfEnumerableMethodRefactoring.cs b/src/Workspaces.Common/CSharp/Refactorings/UseElementAccessInsteadOfEnumerableMethodRefactoring.cs
index 3d884c8f5c..8cd8a8ee70 100644
--- a/src/Workspaces.Common/CSharp/Refactorings/UseElementAccessInsteadOfEnumerableMethodRefactoring.cs
+++ b/src/Workspaces.Common/CSharp/Refactorings/UseElementAccessInsteadOfEnumerableMethodRefactoring.cs
@@ -85,7 +85,6 @@ internal static class UseElementAccessInsteadOfEnumerableMethodRefactoring
     public static Task<Document> UseElementAccessInsteadOfLastAsync(
         Document document,
         InvocationExpressionSyntax invocation,
-        string propertyName,
         CancellationToken cancellationToken = default)
     {
         ArgumentListSyntax argumentList = invocation.ArgumentList;
@@ -105,11 +104,7 @@ internal static class UseElementAccessInsteadOfEnumerableMethodRefactoring
             expression = expression.WithTrailingTrivia(trivia);
         }
 
-        ExpressionSyntax argumentExpression = SubtractExpression(
-            SimpleMemberAccessExpression(
-                expression,
-                IdentifierName(propertyName)),
-            NumericLiteralExpression(1));
+        ExpressionSyntax argumentExpression = ParseExpression("^1");
 
         ElementAccessExpressionSyntax elementAccess = ElementAccessExpression(
             expression,