public void SetInScope(string name, IMember value, bool mergeWithExisting = true, Dictionary <string, IMember> scope = null) { Debug.Assert(_scopes.Count > 0); if (value == null && _scopes.Count == 0) { return; } var s = scope ?? _scopes.Peek(); if (value == null) { s.Remove(name); return; } if (mergeWithExisting && s.TryGetValue(name, out IMember existing) && existing != null) { if (IsUnknown(existing)) { s[name] = value; } else if (!IsUnknown(value)) { s[name] = AstPythonMultipleMembers.Combine(existing, value); } } else { s[name] = value; } }
public void SetInScope(string name, IMember value, bool mergeWithExisting = true) { var s = _scopes.Peek(); if (value == null) { s.Remove(name); return; } if (mergeWithExisting && s.TryGetValue(name, out IMember existing) && existing != null) { if (IsUnknown(existing)) { s[name] = value; } else if (!IsUnknown(value)) { s[name] = AstPythonMultipleMembers.Combine(existing, value); } } else { s[name] = value; } }
private IMember GetValueFromConditional(ConditionalExpression expr, LookupOptions options) { if (expr == null) { return(null); } return(AstPythonMultipleMembers.Combine( GetValueFromExpression(expr.TrueExpression), GetValueFromExpression(expr.FalseExpression) )); }
public void SetInScope(string name, IMember value, bool mergeWithExisting = true) { var s = _scopes.Peek(); if (mergeWithExisting && s.TryGetValue(name, out IMember existing) && existing != null) { s[name] = AstPythonMultipleMembers.Combine(existing, value); } else { s[name] = value; } }
private IMember GetValueFromConditional(ConditionalExpression expr, LookupOptions options) { if (expr == null) { return(null); } var trueValue = GetValueFromExpression(expr.TrueExpression); var falseValue = GetValueFromExpression(expr.FalseExpression); return(trueValue != null || falseValue != null ? AstPythonMultipleMembers.Combine(trueValue, falseValue) : null); }
/// <summary> /// Soft-casts a member to a type, extracting the type from /// a multi-member object if possible. /// </summary> private static IPythonType AsIPythonType(IMember m) { if (m is IPythonType t) { return(t); } if (m is IPythonMultipleMembers mm) { return(AstPythonMultipleMembers.CreateAs <IPythonType>(mm.Members)); } return(null); }
public override IPythonType LookupName(string name) { var m = _scope.LookupNameInScopes(name, NameLookupContext.LookupOptions.Global | NameLookupContext.LookupOptions.Builtins); if (m is IPythonMultipleMembers mm) { m = (IMember)AstPythonMultipleMembers.CreateAs <IPythonType>(mm.Members) ?? AstPythonMultipleMembers.CreateAs <IPythonModule>(mm.Members); } if (m is IPythonModule mod) { // Wrap the module in an IPythonType interface return(new ModuleType(mod)); } return(m as IPythonType); }
public IMember GetMember(IModuleContext context, string name) { IMember res = null; foreach (var m in _modules) { var r = m.GetMember(context, name); if (res == null) { res = r; } else { res = AstPythonMultipleMembers.Combine(res, r); } } return(res); }
public IPythonType GetTypeFromValue(IMember value) { if (value == null) { return(null); } var type = (value as IPythonConstant)?.Type; if (type != null) { return(type); } switch (value.MemberType) { case PythonMemberType.Class: return(Interpreter.GetBuiltinType(BuiltinTypeId.Type)); case PythonMemberType.Delegate: case PythonMemberType.DelegateInstance: case PythonMemberType.Function: return(Interpreter.GetBuiltinType(BuiltinTypeId.Function)); case PythonMemberType.Method: return(Interpreter.GetBuiltinType(BuiltinTypeId.BuiltinMethodDescriptor)); case PythonMemberType.Enum: case PythonMemberType.EnumInstance: break; case PythonMemberType.Module: return(Interpreter.GetBuiltinType(BuiltinTypeId.Module)); case PythonMemberType.Namespace: return(Interpreter.GetBuiltinType(BuiltinTypeId.Object)); case PythonMemberType.Event: break; } IPythonFunction f; if ((f = value as IPythonFunction ?? (value as IPythonBoundFunction)?.Function) != null) { if (f.IsStatic) { return(Interpreter.GetBuiltinType(BuiltinTypeId.StaticMethod)); } else if (f.IsClassMethod) { return(Interpreter.GetBuiltinType(BuiltinTypeId.ClassMethod)); } return(Interpreter.GetBuiltinType(BuiltinTypeId.Function)); } if (value is IBuiltinProperty prop) { return(prop.Type ?? Interpreter.GetBuiltinType(BuiltinTypeId.Property)); } else if (value.MemberType == PythonMemberType.Property) { return(Interpreter.GetBuiltinType(BuiltinTypeId.Property)); } if (value is IPythonMethodDescriptor) { return(Interpreter.GetBuiltinType(BuiltinTypeId.BuiltinMethodDescriptor)); } if (value is IPythonMultipleMembers mm) { return(AstPythonMultipleMembers.CreateAs <IPythonType>(mm.Members)); } if (value is IPythonType) { return(Interpreter.GetBuiltinType(BuiltinTypeId.Type)); } #if DEBUG var implements = string.Join(", ", new[] { value.GetType().FullName }.Concat(value.GetType().GetInterfaces().Select(i => i.Name))); Debug.Fail("Unhandled type() value: " + implements); #endif return(null); }
public async Task <TryImportModuleResult> TryImportModuleAsync(string name, PathResolverSnapshot pathResolver, IReadOnlyList <string> typeStubPaths, bool mergeTypeStubPackages, CancellationToken cancellationToken) { if (string.IsNullOrEmpty(name)) { return(TryImportModuleResult.ModuleNotFound); } Debug.Assert(!name.EndsWithOrdinal("."), $"{name} should not end with '.'"); // Handle builtins explicitly if (name == BuiltinModuleName) { Debug.Fail($"Interpreters must handle import {name} explicitly"); return(TryImportModuleResult.NotSupported); } // Return any existing module if (_modules.TryGetValue(name, out var module) && module != null) { if (module is SentinelModule sentinelModule) { // If we are importing this module on another thread, allow // time for it to complete. This does not block if we are // importing on the current thread or the module is not // really being imported. try { module = await sentinelModule.WaitForImportAsync(cancellationToken); } catch (OperationCanceledException) { _log?.Log(TraceLevel.Warning, "ImportTimeout", name); return(TryImportModuleResult.Timeout); } if (module is SentinelModule) { _log?.Log(TraceLevel.Warning, "RecursiveImport", name); } } return(new TryImportModuleResult(module)); } // Set up a sentinel so we can detect recursive imports var sentinelValue = new SentinelModule(name, true); if (!_modules.TryAdd(name, sentinelValue)) { // Try to get the new module, in case we raced with a .Clear() if (_modules.TryGetValue(name, out module) && !(module is SentinelModule)) { return(new TryImportModuleResult(module)); } // If we reach here, the race is too complicated to recover // from. Signal the caller to try importing again. _log?.Log(TraceLevel.Warning, "RetryImport", name); return(TryImportModuleResult.NeedRetry); } // Do normal searches if (!string.IsNullOrEmpty(_configuration?.InterpreterPath)) { try { module = ImportFromSearchPaths(name, pathResolver); } catch (OperationCanceledException) { _log?.Log(TraceLevel.Error, "ImportTimeout", name, "ImportFromSearchPaths"); return(TryImportModuleResult.Timeout); } } if (module == null) { module = _astModuleCache.ImportFromCache(name, _interpreter); } // Also search for type stub packages if enabled and we are not a blacklisted module if (module != null && typeStubPaths != null && module.Name != "typing") { var tsModule = ImportFromTypeStubs(module.Name, typeStubPaths, pathResolver); if (tsModule != null) { module = mergeTypeStubPackages ? AstPythonMultipleMembers.CombineAs <IPythonModule>(module, tsModule) : tsModule; } } // Replace our sentinel, or if we raced, get the current // value and abandon the one we just created. if (!_modules.TryUpdate(name, module, sentinelValue)) { // Try to get the new module, in case we raced if (_modules.TryGetValue(name, out module) && !(module is SentinelModule)) { return(new TryImportModuleResult(module)); } // If we reach here, the race is too complicated to recover // from. Signal the caller to try importing again. _log?.Log(TraceLevel.Warning, "RetryImport", name); return(TryImportModuleResult.NeedRetry); } sentinelValue.Complete(module); return(new TryImportModuleResult(module)); }