Adding error message on no arguments to Generic

Author: CTrando

src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Generics.cs

@@ -65,16 +65,24 @@ private IMember GetValueFromGeneric(IMember target, Expression expr) {
         /// <summary>
         /// Returns whether the arguments to Generic are valid
         /// </summary>
-        private bool GenericClassParameterValid(IGenericTypeDefinition[] genericTypeArgs, IReadOnlyList<IMember> indices, Expression expr) {
-            if (genericTypeArgs.Length == 0) {
+        private bool GenericClassParameterValid(IReadOnlyList<IGenericTypeDefinition> genericTypeArgs, IReadOnlyList<IMember> indices, Expression expr) {
+            // Cannot have Generic[]
+            if (genericTypeArgs.Count == 0) {
+                ReportDiagnostics(Module.Uri, new DiagnosticsEntry(
+                    Resources.GenericTooFewArguments,
+                    GetLocation(expr).Span,
+                    ErrorCodes.GenericArguments,
+                    Severity.Error,
+                    DiagnosticSource.Analysis));
+
                 return false;
             }
 
             // All arguments to Generic must be type parameters
             // e.g. Generic[T, str] throws a runtime error
-            if (genericTypeArgs.Length != indices.Count) {
+            if (genericTypeArgs.Count != indices.Count) {
                 ReportDiagnostics(Module.Uri, new DiagnosticsEntry(
-                    Resources.GenericArgumentsNotAllTypeParameters,
+                    Resources.GenericNotAllTypeParameters,
                     GetLocation(expr).Span,
                     ErrorCodes.GenericArguments,
                     Severity.Error,
@@ -83,9 +91,9 @@ private bool GenericClassParameterValid(IGenericTypeDefinition[] genericTypeArgs
             }
 
             // All arguments to Generic must be distinct
-            if (genericTypeArgs.Distinct().Count() != genericTypeArgs.Length) {
+            if (genericTypeArgs.Distinct().Count() != genericTypeArgs.Count) {
                 ReportDiagnostics(Module.Uri, new DiagnosticsEntry(
-                   Resources.GenericArgumentsNotAllUnique,
+                   Resources.GenericNotAllUnique,
                    GetLocation(expr).Span,
                    ErrorCodes.GenericArguments,
                    Severity.Error,

src/Analysis/Ast/Impl/Resources.Designer.cs

@@ -189,10 +189,13 @@
   <data name="UnableToDetermineCachePathException" xml:space="preserve">
     <value>Unable to determine analysis cache path. Exception: {0}. Using default '{1}'.</value>
   </data>
-  <data name="GenericArgumentsNotAllTypeParameters" xml:space="preserve">
+  <data name="GenericNotAllTypeParameters" xml:space="preserve">
     <value>Arguments to Generic must all be type parameters.</value>
   </data>
-  <data name="GenericArgumentsNotAllUnique" xml:space="preserve">
+  <data name="GenericNotAllUnique" xml:space="preserve">
     <value>Arguments to Generic must all be unique.</value>
   </data>
+  <data name="GenericTooFewArguments" xml:space="preserve">
+    <value>Not enough arguments for Generic.</value>
+  </data>
 </root>

src/Analysis/Ast/Impl/Resources.resx

@@ -1,11 +1,7 @@
-using System;
-using System.Collections.Generic;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
-using FluentAssertions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using NSubstitute;
 using TestUtilities;
 
 namespace Microsoft.Python.Analysis.Tests {
@@ -27,6 +23,25 @@ public void TestInitialize()
         [TestCleanup]
         public void Cleanup() => TestEnvironmentImpl.TestCleanup();
 
+        [DataRow(GenericSetup + @"
+class Map(Generic[]):
+    def hello():
+        pass
+")]
+        [DataRow(GenericSetup + @"
+G = Generic[]
+")]
+        [DataTestMethod, Priority(0)]
+        public async Task GenericTooFewArguments(string code) {
+            var analysis = await GetAnalysisAsync(code);
+            analysis.Diagnostics.Should().HaveCount(1);
+
+            var diagnostic = analysis.Diagnostics.ElementAt(0);
+            diagnostic.ErrorCode.Should().Be(Diagnostics.ErrorCodes.GenericArguments);
+            diagnostic.Message.Should().Be(Resources.GenericTooFewArguments);
+        }
+
+
         [DataRow(GenericSetup + @"
 class Map(Generic[T, str]):
     def hello():
@@ -43,13 +58,13 @@ def hello():
         pass
 ")]
         [DataTestMethod, Priority(0)]
-        public async Task GenericArgumentsNotAllTypeParameters(string code) {
+        public async Task GenericNotALlTypParameters(string code) {
             var analysis = await GetAnalysisAsync(code);
             analysis.Diagnostics.Should().HaveCount(1);
 
             var diagnostic = analysis.Diagnostics.ElementAt(0);
             diagnostic.ErrorCode.Should().Be(Diagnostics.ErrorCodes.GenericArguments);
-            diagnostic.Message.Should().Be(Resources.GenericArgumentsNotAllTypeParameters);
+            diagnostic.Message.Should().Be(Resources.GenericNotAllTypeParameters);
         }
 
         [DataRow(GenericSetup + @"
@@ -82,13 +97,13 @@ def hello():
         pass
 ")]
         [DataTestMethod, Priority(0)]
-        public async Task GenericArgumentsDuplicate(string code) {
+        public async Task GenericDuplicateArguments(string code) {
             var analysis = await GetAnalysisAsync(code);
             analysis.Diagnostics.Should().HaveCount(1);
 
             var diagnostic = analysis.Diagnostics.ElementAt(0);
             diagnostic.ErrorCode.Should().Be(Diagnostics.ErrorCodes.GenericArguments);
-            diagnostic.Message.Should().Be(Resources.GenericArgumentsNotAllUnique);
+            diagnostic.Message.Should().Be(Resources.GenericNotAllUnique);
         }
 
  [DataRow(GenericSetup + @"