Revert "When a class inherits from something that is not a class, give a diagnostic error (#1277)"

This reverts commit 39d7437.

Author: Mikhail Arkhipov

src/Analysis/Ast/Impl/Analyzer/Symbols/ClassEvaluator.cs

@@ -13,15 +13,12 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.Python.Analysis.Analyzer.Evaluation;
-using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Types;
 using Microsoft.Python.Analysis.Values;
 using Microsoft.Python.Core;
-using Microsoft.Python.Parsing;
 using Microsoft.Python.Parsing.Ast;
 
 namespace Microsoft.Python.Analysis.Analyzer.Symbols {
@@ -53,12 +50,22 @@ public void EvaluateClass() {
                 EvaluateInnerClasses(_classDef);
 
                 _class = classInfo;
-
-                var bases = ProcessBases(outerScope);
-
+                // Set bases to the class.
+                var bases = new List<IPythonType>();
+                foreach (var a in _classDef.Bases.Where(a => string.IsNullOrEmpty(a.Name))) {
+                    // We cheat slightly and treat base classes as annotations.
+                    var b = Eval.GetTypeFromAnnotation(a.Expression);
+                    if (b != null) {
+                        var t = b.GetPythonType();
+                        bases.Add(t);
+                        t.AddReference(Eval.GetLocationOfName(a.Expression));
+                    }
+                }
                 _class.SetBases(bases);
+
                 // Declare __class__ variable in the scope.
                 Eval.DeclareVariable("__class__", _class, VariableSource.Declaration);
+
                 ProcessClassBody();
             }
         }
@@ -111,47 +118,6 @@ private void ProcessClassBody() {
             UpdateClassMembers();
         }
 
-        private IEnumerable<IPythonType> ProcessBases(Scope outerScope) {
-            var bases = new List<IPythonType>();
-            foreach (var a in _classDef.Bases.Where(a => string.IsNullOrEmpty(a.Name))) {
-                var expr = a.Expression;
-
-                switch (expr) {
-                    // class declared in the current module
-                    case NameExpression nameExpression:
-                        var name = Eval.GetInScope(nameExpression.Name, outerScope);
-                        switch (name) {
-                            case PythonClassType classType:
-                                bases.Add(classType);
-                                break;
-                            case IPythonConstant constant:
-                                ReportInvalidBase(constant.Value);
-                                break;
-                            default:
-                                TryAddBase(bases, a);
-                                break;
-                        }
-                        break;
-                    default:
-                        TryAddBase(bases, a);
-                        break;
-                }
-            }
-            return bases;
-        }
-
-        private void TryAddBase(List<IPythonType> bases, Arg arg) {
-            // We cheat slightly and treat base classes as annotations.
-            var b = Eval.GetTypeFromAnnotation(arg.Expression);
-            if (b != null) {
-                var t = b.GetPythonType();
-                bases.Add(t);
-                t.AddReference(Eval.GetLocationOfName(arg.Expression));
-            } else {
-                ReportInvalidBase(arg.ToCodeString(Eval.Ast, CodeFormattingOptions.Traditional));
-            }
-        }
-
         private void EvaluateConstructors(ClassDefinition cd) {
             // Do not use foreach since walker list is dynamically modified and walkers are removed
             // after processing. Handle __init__ and __new__ first so class variables are initialized.
@@ -186,17 +152,6 @@ private void UpdateClassMembers() {
             _class.AddMembers(members, false);
         }
 
-        private void ReportInvalidBase(object argVal) {
-            Eval.ReportDiagnostics(Eval.Module.Uri,
-                new DiagnosticsEntry(
-                Resources.InheritNonClass.FormatInvariant(argVal),
-                _classDef.NameExpression.GetLocation(Eval)?.Span ?? default,
-                Diagnostics.ErrorCodes.InheritNonClass,
-                Severity.Error,
-                DiagnosticSource.Analysis
-            ));
-        }
-
         // Classes and functions are walked by their respective evaluators
         public override bool Walk(ClassDefinition node) => false;
         public override bool Walk(FunctionDefinition node) => false;

src/Analysis/Ast/Impl/Diagnostics/ErrorCodes.cs

@@ -29,6 +29,5 @@ public static class ErrorCodes {
         public const string ReturnInInit = "return-in-init";
         public const string TypingNewTypeArguments = "typing-newtype-arguments";
         public const string TypingGenericArguments = "typing-generic-arguments";
-        public const string InheritNonClass = "inherit-non-class";
     }
 }

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

@@ -204,7 +204,4 @@
   <data name="GenericNotAllUnique" xml:space="preserve">
     <value>Arguments to Generic must all be unique.</value>
   </data>
-  <data name="InheritNonClass" xml:space="preserve">
-    <value>Inheriting '{0}', which is not a class.</value>
-  </data>
-</root>
+</root>

src/Analysis/Ast/Impl/Resources.resx

@@ -17,8 +17,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using Microsoft.Python.Analysis.Analyzer;
-using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Modules;
 using Microsoft.Python.Analysis.Specializations.Typing;
 using Microsoft.Python.Analysis.Types.Collections;
@@ -192,7 +190,6 @@ internal void SetBases(IEnumerable<IPythonType> bases) {
             }
 
             bases = bases != null ? bases.Where(b => !b.GetPythonType().IsUnknown()).ToArray() : Array.Empty<IPythonType>();
-
             // For Python 3+ attach object as a base class by default except for the object class itself.
             if (DeclaringModule.Interpreter.LanguageVersion.Is3x() && DeclaringModule.ModuleType != ModuleType.Builtins) {
                 var objectType = DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object);