Add class member lock protection (microsoft#1491)

Mikhail Arkhipov · web-flow · commit 22832f7546f4 · 2019-09-03T14:56:38.000-07:00
* Add class member lock protection

* usings

* Fix null ref
diff --git a/src/Analysis/Ast/Impl/Types/PythonClassType.Generics.cs b/src/Analysis/Ast/Impl/Types/PythonClassType.Generics.cs
@@ -25,7 +25,6 @@ namespace Microsoft.Python.Analysis.Types {
     internal partial class PythonClassType {
         private readonly ReentrancyGuard<IPythonClassType> _genericSpecializationGuard = new ReentrancyGuard<IPythonClassType>();
         private readonly ReentrancyGuard<IPythonClassType> _genericResolutionGuard = new ReentrancyGuard<IPythonClassType>();
-        private readonly object _genericParameterLock = new object();
 
         private bool _isGeneric;
         private Dictionary<string, PythonClassType> _specificTypeCache;
@@ -60,7 +59,7 @@ internal partial class PythonClassType {
         /// B[int] inherits from A[int, str] 
         /// </summary>
         public IPythonType CreateSpecificType(IArgumentSet args) {
-            lock (_genericParameterLock) {
+            lock (_membersLock) {
                 var newGenericTypeParameters = GetTypeParameters();
                 var newBases = new List<IPythonType>();
 
@@ -161,18 +160,18 @@ private IGenericTypeParameter[] GetTypeParameters() {
                     }
                 }
             }
-
             return fromBases.ToArray();
         }
 
         /// <summary>
         /// Given an argument set, returns a dictionary mapping generic type parameter to the supplied specific 
         /// type from arguments. 
         /// </summary>
-        private IReadOnlyDictionary<IGenericTypeParameter, IPythonType> GetSpecificTypes(IArgumentSet args,
-            IGenericTypeParameter[] genericTypeParameters,
-            List<IPythonType> newBases) {
-
+        private IReadOnlyDictionary<IGenericTypeParameter, IPythonType> GetSpecificTypes(
+            IArgumentSet args,
+            IReadOnlyList<IGenericTypeParameter> genericTypeParameters,
+            ICollection<IPythonType> newBases
+            ) {
             // For now, map each type parameter to itself, and we can fill in the value as we go 
             var genericTypeToSpecificType = genericTypeParameters.ToDictionary(gtp => gtp, gtp => gtp as IPythonType);
 
@@ -240,7 +239,7 @@ private IReadOnlyDictionary<IGenericTypeParameter, IPythonType> GetSpecificTypes
                 if (arg.Value is IMember member) {
                     var type = member.GetPythonType();
                     if (!type.IsUnknown()) {
-                        var gtd = gtIndex < genericTypeParameters.Length ? genericTypeParameters[gtIndex] : null;
+                        var gtd = gtIndex < genericTypeParameters.Count ? genericTypeParameters[gtIndex] : null;
                         if (gtd != null && genericTypeToSpecificType.TryGetValue(gtd, out var s) && s is IGenericTypeParameter) {
                             genericTypeToSpecificType[gtd] = type;
                         }
@@ -304,7 +303,7 @@ private void StoreGenericParameters(
         /// <param name="gt">Generic type (Generic[T1, T2, ...], A[T1, T2, ..], etc.).</param>
         /// <param name="argumentValue">Argument value passed to the class constructor.</param>
         /// <param name="specificTypes">Dictionary or name (T1) to specific type to populate.</param>
-        private void GetSpecificTypeFromArgumentValue(IGenericType gt, object argumentValue, IDictionary<IGenericTypeParameter, IPythonType> specificTypes) {
+        private static void GetSpecificTypeFromArgumentValue(IGenericType gt, object argumentValue, IDictionary<IGenericTypeParameter, IPythonType> specificTypes) {
             switch (argumentValue) {
                 case IPythonDictionary dict when gt.Parameters.Count == 2:
                     var keyType = dict.Keys.FirstOrDefault()?.GetPythonType();
diff --git a/src/Analysis/Ast/Impl/Types/PythonClassType.cs b/src/Analysis/Ast/Impl/Types/PythonClassType.cs
@@ -35,6 +35,8 @@ internal partial class PythonClassType : PythonType, IPythonClassType, IEquatabl
         private static readonly string[] _classMethods = { "mro", "__dict__", @"__weakref__" };
 
         private readonly ReentrancyGuard<IPythonClassType> _memberGuard = new ReentrancyGuard<IPythonClassType>();
+        private readonly object _membersLock = new object();
+
         private string _genericName;
         private List<IPythonType> _bases;
         private IReadOnlyList<IPythonType> _mro;
@@ -60,18 +62,22 @@ public PythonClassType(ClassDefinition classDefinition, Location location, Built
         public override PythonMemberType MemberType => PythonMemberType.Class;
 
         public override IEnumerable<string> GetMemberNames() {
-            var names = new HashSet<string>();
-            names.UnionWith(Members.Keys);
-            foreach (var m in Mro.Skip(1)) {
-                names.UnionWith(m.GetMemberNames());
+            lock (_membersLock) {
+                var names = new HashSet<string>(Members.Keys);
+                foreach (var m in Mro.Skip(1)) {
+                    names.UnionWith(m.GetMemberNames());
+                }
+                return DeclaringModule.Interpreter.LanguageVersion.Is3x() ? names.Concat(_classMethods).Distinct() : names;
             }
-            return DeclaringModule.Interpreter.LanguageVersion.Is3x() ? names.Concat(_classMethods).Distinct() : names;
         }
 
         public override IMember GetMember(string name) {
-            // Push/Pop should be lock protected.
-            if (Members.TryGetValue(name, out var member)) {
-                return member;
+            IMember member;
+
+            lock (_membersLock) {
+                if (Members.TryGetValue(name, out member)) {
+                    return member;
+                }
             }
 
             // Special case names that we want to add to our own Members dict
@@ -159,12 +165,17 @@ public override IMember Index(IPythonInstance instance, IArgumentSet args) {
 
             return fromBases ?? defaultReturn;
         }
-
         #endregion
 
         #region IPythonClass
         public ClassDefinition ClassDefinition => DeclaringModule.GetAstNode<ClassDefinition>(this);
-        public IReadOnlyList<IPythonType> Bases => _bases;
+        public IReadOnlyList<IPythonType> Bases {
+            get {
+                lock(_membersLock) {
+                    return _bases?.ToArray();
+                }
+            }
+        }
 
         public IReadOnlyList<IPythonType> Mro {
             get {
