Added an option to propagate parameter types to base methods

src/Analysis/Engine/Impl/AnalysisLimits.cs

@@ -180,6 +180,12 @@ public AnalysisLimits() {
         /// </summary>
         public bool ProcessCustomDecorators { get; set; }
 
+        /// <summary>
+        /// <c>True</c> to propagate parameter types to base methods.
+        /// Parameter types always propagate to derived methods.
+        /// </summary>
+        public bool PropagateParameterTypeToBaseMethods { get; set; }
+
         /// <summary>
         /// True to read information from type stub packages.
         /// </summary>

src/Analysis/Engine/Impl/Analyzer/DDG.cs

@@ -454,7 +454,7 @@ private bool TryImportModule(string modName, bool forceAbsolute, out ModuleRefer
             return false;
         }
 
-        internal List<AnalysisValue> LookupBaseMethods(string name, IEnumerable<IAnalysisSet> mro, Node node, AnalysisUnit unit) {
+        internal static List<AnalysisValue> LookupBaseMethods(string name, IEnumerable<IAnalysisSet> mro, Node node, AnalysisUnit unit) {
             var result = new List<AnalysisValue>();
             foreach (var @class in mro.Skip(1)) {
                 foreach (var curType in @class) {

src/Analysis/Engine/Impl/Values/FunctionInfo.cs

@@ -103,6 +103,14 @@ public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] a
                 }
             }
 
+            if (_analysisUnit.State.Limits.PropagateParameterTypeToBaseMethods
+                && _analysisUnit.Scope.OuterScope is ClassScope parentClass) {
+                var baseMethods = DDG.LookupBaseMethods(Name, parentClass.Class.Mro, AnalysisUnit.Ast, AnalysisUnit);
+                foreach (FunctionInfo baseMethod in baseMethods.OfType<FunctionInfo>()) {
+                    baseMethod.DoCall(node, unit, baseMethod._analysisUnit, callArgs);
+                }
+            }
+
             if (_callsWithClosure != null) {
                 var chain = new CallChain(node, unit, _callDepthLimit);
                 var aggregate = GetAggregate(unit);

src/Analysis/Engine/Test/InheritanceTests.cs

@@ -83,5 +83,33 @@ def foo(self, x):
             analysis.Should().HaveClass("Derived").WithFunction("foo")
                 .WithParameter("x").OfType(BuiltinTypeId.Int);
         }
+
+        [TestMethod]
+        public async Task ParameterTypesPropagateToBaseFunctions() {
+            var code = @"
+class Baze:
+  def foo(self, x):
+    pass
+
+class Derived(Baze):
+  def foo(self, x):
+    pass
+
+Derived().foo(42)
+";
+
+            using (var server = await new Server().InitializeAsync(PythonVersions.Required_Python36X)) {
+                server.Analyzer.Limits.PropagateParameterTypeToBaseMethods = true;
+
+                var analysis = await server.OpenDefaultDocumentAndGetAnalysisAsync(code);
+
+                // the class, for which we know parameter type initially
+                analysis.Should().HaveClass("Derived").WithFunction("foo")
+                    .WithParameter("x").OfType(BuiltinTypeId.Int);
+                // its base class
+                analysis.Should().HaveClass("Baze").WithFunction("foo")
+                    .WithParameter("x").OfType(BuiltinTypeId.Int);
+            }
+        }
     }
 }