more simple clean ups

named arguments, removing unncessary stuff.

Author: heejaechang

src/Analysis/Core/Impl/Interpreter/InterpreterConfiguration.cs

@@ -22,7 +22,7 @@ public sealed class InterpreterConfiguration : IEquatable<InterpreterConfigurati
         /// Constructs a new interpreter configuration based on the provided values.
         /// </summary>
         public InterpreterConfiguration(string interpreterPath = null, Version version = null) :
-            this(interpreterPath, string.Empty, null, null, default, version) { }
+            this(interpreterPath, pathVar: string.Empty, libPath: null, sitePackagesPath: null, architecture: default, version: version) { }
 
         // Tests only
         internal InterpreterConfiguration(
@@ -31,8 +31,7 @@ internal InterpreterConfiguration(
             string libPath = null,
             string sitePackagesPath = null,
             InterpreterArchitecture architecture = default,
-            Version version = null
-        ) {
+            Version version = null) {
             InterpreterPath = interpreterPath;
             PathEnvironmentVariable = pathVar;
             Architecture = architecture ?? InterpreterArchitecture.Unknown;

src/Core/Impl/Collections/ImmutableArray.cs

@@ -91,6 +91,10 @@ public ImmutableArray<T> Add(T item) {
             var newItems = _items;
             var newRef = _ref;
 
+            // _ref indicates whether the array "_items" can be re-used when creating new ImmutableArray.
+            // this is an optimization to reduce array allocation while new elements are kept added at the end of the list
+            // this is an alternative design compared to Builder model 
+            // (https://docs.microsoft.com/en-us/dotnet/api/system.collections.immutable.immutablearray-1.builder)
             if (Interlocked.CompareExchange(ref newRef.Count, newCount, _count) != _count || newCount > _items.Length) {
                 var capacity = GetCapacity(newCount);
                 newItems = new T[capacity];

src/Core/Impl/Extensions/TaskExtensions.cs

@@ -105,7 +105,16 @@ private static void DoNotWaitSynchronizationContextContinuation(Task task, objec
         /// </summary>
         public static T WaitAndUnwrapExceptions<T>(this Task<T> task) => task.GetAwaiter().GetResult();
 
+        /// <summary>
+        /// Attach new <see cref="CancellationToken" /> to the given task.
+        /// 
+        /// this allows caller to have its own cancellation without aborting underlying work.
+        /// 
+        /// if <paramref name="task"/> uses different cancellation token than one given <paramref name="cancellationToken"/>
+        /// it will throw <see cref="AggregateException" /> instead of <see cref="OperationCanceledException" /> and
+        /// Task will be set to faulted rather than cancelled.
+        /// </summary>
         public static Task<T> WaitAsync<T>(this Task<T> task, CancellationToken cancellationToken) 
-            => task.ContinueWith(t => t.GetAwaiter().GetResult(), cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default);
+            => task.ContinueWith(t => t.WaitAndUnwrapExceptions(), cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default);
     }
 }

src/Core/Impl/Services/IdleTimeService.cs

@@ -19,11 +19,15 @@
 
 namespace Microsoft.Python.Core.Services {
     public sealed class IdleTimeService : IIdleTimeService, IIdleTimeTracker, IDisposable {
+        private static readonly TimeSpan s_initialDelay = TimeSpan.FromMilliseconds(50);
+        private static readonly TimeSpan s_interval = TimeSpan.FromMilliseconds(50);
+        private static readonly TimeSpan s_idleInterval = TimeSpan.FromMilliseconds(100);
+
         private Timer _timer;
         private DateTime _lastActivityTime;
 
         public IdleTimeService() {
-            _timer = new Timer(OnTimer, this, 50, 50);
+            _timer = new Timer(OnTimer, state: this, s_initialDelay, s_interval);
             NotifyUserActivity();
         }
 
@@ -32,11 +36,12 @@ public IdleTimeService() {
         public void Dispose() {
             _timer?.Dispose();
             _timer = null;
+
             Closing?.Invoke(this, EventArgs.Empty);
         }
 
         private void OnTimer(object state) {
-            if ((DateTime.Now - _lastActivityTime).TotalMilliseconds >= 100 && _timer != null) {
+            if (_timer != null && (DateTime.Now - _lastActivityTime) >= s_idleInterval) {
                 Idle?.Invoke(this, EventArgs.Empty);
             }
         }

src/Core/Impl/Text/SourceLocation.cs

@@ -49,7 +49,7 @@ public SourceLocation(int index, int line, int column) {
         /// <param name="column">The column in the source stream the location represents (1-based).</param>
         [DebuggerStepThrough]
         public SourceLocation(int line, int column) {
-            ValidateLocation(0, line, column);
+            ValidateLocation(index: 0, line, column);
 
             _index = -1;
             Line = line;

src/Core/Impl/Threading/SingleThreadSynchronizationContext.cs

@@ -20,7 +20,7 @@
 
 namespace Microsoft.Python.Core.Threading {
     public class SingleThreadSynchronizationContext : SynchronizationContext, IDisposable {
-        private readonly ConcurrentQueue<Tuple<SendOrPostCallback, object>> _queue = new ConcurrentQueue<Tuple<SendOrPostCallback, object>>();
+        private readonly ConcurrentQueue<(SendOrPostCallback callback, object state)> _queue = new ConcurrentQueue<(SendOrPostCallback, object)>();
         private readonly ManualResetEventSlim _workAvailable = new ManualResetEventSlim(false);
         private readonly CancellationTokenSource _cts = new CancellationTokenSource();
 
@@ -29,7 +29,7 @@ public SingleThreadSynchronizationContext() {
         }
 
         public override void Post(SendOrPostCallback d, object state) {
-            _queue.Enqueue(new Tuple<SendOrPostCallback, object>(d, state));
+            _queue.Enqueue((d, state));
             _workAvailable.Set();
         }
 
@@ -41,9 +41,10 @@ private void QueueWorker() {
                 if (_cts.IsCancellationRequested) {
                     break;
                 }
-                while (_queue.TryDequeue(out var t)) {
-                    t.Item1(t.Item2);
+                while (_queue.TryDequeue(out var entry)) {
+                    entry.callback(entry.state);
                 }
+
                 _workAvailable.Reset();
             }
         }

src/LanguageServer/Impl/LanguageServer.Configuration.cs

@@ -51,19 +51,19 @@ public async Task DidChangeConfiguration(JToken token, CancellationToken cancell
                 }
 
                 var autoComplete = pythonSection["autoComplete"];
-                settings.completion.showAdvancedMembers = GetSetting(autoComplete, "showAdvancedMembers", true);
-                settings.completion.addBrackets = GetSetting(autoComplete, "addBrackets", false);
+                settings.completion.showAdvancedMembers = GetSetting(autoComplete, "showAdvancedMembers", defaultValue: true);
+                settings.completion.addBrackets = GetSetting(autoComplete, "addBrackets", defaultValue: false);
 
                 var analysis = pythonSection["analysis"];
-                settings.symbolsHierarchyDepthLimit = GetSetting(analysis, "symbolsHierarchyDepthLimit", 10);
-                settings.symbolsHierarchyMaxSymbols = GetSetting(analysis, "symbolsHierarchyMaxSymbols", 1000);
+                settings.symbolsHierarchyDepthLimit = GetSetting(analysis, "symbolsHierarchyDepthLimit", defaultValue: 10);
+                settings.symbolsHierarchyMaxSymbols = GetSetting(analysis, "symbolsHierarchyMaxSymbols", defaultValue: 1000);
 
                 _logger.LogLevel = GetLogLevel(analysis).ToTraceEventType();
 
                 var userConfiguredPaths = GetUserConfiguredPaths(pythonSection);
 
                 HandleUserConfiguredPathsChanges(userConfiguredPaths);
-                HandlePathWatchChanges(GetSetting(analysis, "watchSearchPaths", true));
+                HandlePathWatchChanges(GetSetting(analysis, "watchSearchPaths", defaultValue: true));
                 HandleDiagnosticsChanges(pythonSection, settings);
 
                 _server.DidChangeConfiguration(new DidChangeConfigurationParams { settings = settings }, cancellationToken);
@@ -73,23 +73,23 @@ public async Task DidChangeConfiguration(JToken token, CancellationToken cancell
         private void HandleDiagnosticsChanges(JToken pythonSection, LanguageServerSettings settings) {
             var analysis = pythonSection["analysis"];
 
-            settings.diagnosticPublishDelay = GetSetting(analysis, "diagnosticPublishDelay", 1000);
+            settings.diagnosticPublishDelay = GetSetting(analysis, "diagnosticPublishDelay", defaultValue: 1000);
             var ds = _services.GetService<IDiagnosticsService>();
             ds.PublishingDelay = settings.diagnosticPublishDelay;
 
             ds.DiagnosticsSeverityMap = new DiagnosticsSeverityMap(
-                GetSetting(analysis, "errors", Array.Empty<string>()),
-                GetSetting(analysis, "warnings", Array.Empty<string>()),
-                GetSetting(analysis, "information", Array.Empty<string>()),
-                GetSetting(analysis, "disabled", Array.Empty<string>()));
+                GetSetting(analysis, "errors", defaultValue: Array.Empty<string>()),
+                GetSetting(analysis, "warnings", defaultValue: Array.Empty<string>()),
+                GetSetting(analysis, "information", defaultValue: Array.Empty<string>()),
+                GetSetting(analysis, "disabled", defaultValue: Array.Empty<string>()));
 
             var linting = pythonSection["linting"];
-            HandleLintingOnOff(_services, GetSetting(linting, "enabled", true));
+            HandleLintingOnOff(_services, GetSetting(linting, "enabled", defaultValue: true));
 
             var memory = analysis["memory"];
             var optionsProvider = _services.GetService<IAnalysisOptionsProvider>();
-            optionsProvider.Options.KeepLibraryLocalVariables = GetSetting(memory, "keepLibraryLocalVariables", false);
-            optionsProvider.Options.KeepLibraryAst = GetSetting(memory, "keepLibraryAst", false);
+            optionsProvider.Options.KeepLibraryLocalVariables = GetSetting(memory, "keepLibraryLocalVariables", defaultValue: false);
+            optionsProvider.Options.KeepLibraryAst = GetSetting(memory, "keepLibraryAst", defaultValue: false);
             optionsProvider.Options.AnalysisCachingLevel = GetAnalysisCachingLevel(analysis);
 
             _logger?.Log(TraceEventType.Information, Resources.AnalysisCacheLevel.FormatInvariant(optionsProvider.Options.AnalysisCachingLevel));
@@ -135,10 +135,10 @@ private ImmutableArray<string> GetUserConfiguredPaths(JToken pythonSection) {
                 // The values of these may not be null even if the value is "unset", depending on
                 // what the client uses as a default. Use null as a default anyway until the
                 // extension uses a null default (and/or extraPaths is dropped entirely).
-                var autoCompleteExtraPaths = GetSetting<IReadOnlyList<string>>(autoComplete, "extraPaths", null);
-                var analysisSearchPaths = GetSetting<IReadOnlyList<string>>(analysis, "searchPaths", null);
-                var analysisUsePYTHONPATH = GetSetting(analysis, "usePYTHONPATH", true);
-                var analayisAutoSearchPaths = GetSetting(analysis, "autoSearchPaths", true);
+                var autoCompleteExtraPaths = GetSetting<IReadOnlyList<string>>(autoComplete, "extraPaths", defaultValue: null);
+                var analysisSearchPaths = GetSetting<IReadOnlyList<string>>(analysis, "searchPaths", defaultValue: null);
+                var analysisUsePYTHONPATH = GetSetting(analysis, "usePYTHONPATH", defaultValue: true);
+                var analayisAutoSearchPaths = GetSetting(analysis, "autoSearchPaths", defaultValue: true);
 
                 if (analysisSearchPaths != null) {
                     set = true;
@@ -181,7 +181,7 @@ private ImmutableArray<string> GetUserConfiguredPaths(JToken pythonSection) {
         }
 
         private AnalysisCachingLevel GetAnalysisCachingLevel(JToken analysisKey) {
-            var s = GetSetting(analysisKey, "cachingLevel", "None");
+            var s = GetSetting(analysisKey, "cachingLevel", defaultValue: "None");
             if (s.EqualsIgnoreCase("System")) {
                 return AnalysisCachingLevel.System;
             }

src/LanguageServer/Impl/PathsWatcher.cs

@@ -90,7 +90,7 @@ private void OnChanged(object sender, FileSystemEventArgs e) {
             // if there is massive change to the file structure.
             lock (_lock) {
                 _changedSinceLastTick = true;
-                _throttleTimer = _throttleTimer ?? new Timer(TimerProc, null, 500, 500);
+                _throttleTimer = _throttleTimer ?? new Timer(TimerProc, state: null, dueTime: 500, period: 500);
             }
         }