Add the internal access modifier for types, operations, and functions

src/QsCompiler/CommandLineTool/LoadContext.cs

@@ -23,7 +23,7 @@ namespace Microsoft.Quantum.QsCompiler
     public class LoadContext : AssemblyLoadContext
     {
         public readonly string PathToParentAssembly;
-        private AssemblyDependencyResolver _Resolver;
+        private readonly AssemblyDependencyResolver _Resolver;
         private readonly HashSet<string> _FallbackPaths;
 
         /// <summary>
@@ -111,7 +111,7 @@ private Assembly OnResolving(AssemblyLoadContext context, AssemblyName name)
             return path == null ? null : LoadFromAssemblyPath(path);
         }
 
-        private static ConcurrentBag<LoadContext> Loaded =
+        private static readonly ConcurrentBag<LoadContext> Loaded =
             new ConcurrentBag<LoadContext>();
 
         /// <summary>

src/QsCompiler/CompilationManager/EditorSupport/CodeActions.cs

@@ -10,6 +10,7 @@
 using Microsoft.Quantum.QsCompiler.Diagnostics;
 using Microsoft.Quantum.QsCompiler.SyntaxProcessing;
 using Microsoft.Quantum.QsCompiler.SyntaxTokens;
+using Microsoft.Quantum.QsCompiler.SyntaxTree;
 using Microsoft.Quantum.QsCompiler.TextProcessing;
 using Microsoft.Quantum.QsCompiler.Transformations.QsCodeOutput;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -38,9 +39,13 @@ private static WorkspaceEdit GetWorkspaceEdit(this FileContentManager file, para
         }
 
         /// <summary>
-        /// Returns all namespaces in which a callable with the name of the symbol at the given position in the given file belongs to.
-        /// Returns an empty collection if any of the arguments is null or if no unqualified symbol exists at that location.
-        /// Returns the name of the identifier as out parameter if an unqualified symbol exists at that location.
+        /// Returns all namespaces in which a callable with the name of the symbol at the given position in the given
+        /// file belongs to.
+        ///
+        /// Returns an empty collection if any of the arguments is null, if no unqualified symbol exists at that
+        /// location, or if the position is not part of a namespace.
+        ///
+        /// Returns the name of the identifier as an out parameter if an unqualified symbol exists at that location.
         /// </summary>
         private static IEnumerable<NonNullable<string>> NamespaceSuggestionsForIdAtPosition
             (this FileContentManager file, Position pos, CompilationUnit compilation, out string idName)
@@ -53,9 +58,13 @@ private static IEnumerable<NonNullable<string>> NamespaceSuggestionsForIdAtPosit
         }
 
         /// <summary>
-        /// Returns all namespaces in which a type with the name of the symbol at the given position in the given file belongs to.
-        /// Returns an empty collection if any of the arguments is null or if no unqualified symbol exists at that location.
-        /// Returns the name of the type as out parameter if an unqualified symbol exists at that location.
+        /// Returns all namespaces in which a type with the name of the symbol at the given position in the given file
+        /// belongs to.
+        ///
+        /// Returns an empty collection if any of the arguments is null, if no unqualified symbol exists at that
+        /// location, or if the position is not part of a namespace.
+        ///
+        /// Returns the name of the type as an out parameter if an unqualified symbol exists at that location.
         /// </summary>
         private static IEnumerable<NonNullable<string>> NamespaceSuggestionsForTypeAtPosition
             (this FileContentManager file, Position pos, CompilationUnit compilation, out string typeName)
@@ -233,9 +242,9 @@ static string CharacteristicsAnnotation(Characteristics c)
                 static IEnumerable<Characteristics> GetCharacteristics(QsTuple<Tuple<QsSymbol, QsType>> argTuple) =>
                     SyntaxGenerator.ExtractItems(argTuple).SelectMany(item => item.Item2.ExtractCharacteristics()).Distinct();
                 var characteristicsInFragment =
-                    fragment?.Kind is QsFragmentKind.FunctionDeclaration function ? GetCharacteristics(function.Item2.Argument) :
-                    fragment?.Kind is QsFragmentKind.OperationDeclaration operation ? GetCharacteristics(operation.Item2.Argument) :
-                    fragment?.Kind is QsFragmentKind.TypeDefinition type ? GetCharacteristics(type.Item2) :
+                    fragment?.Kind is QsFragmentKind.FunctionDeclaration function ? GetCharacteristics(function.Item3.Argument) :
+                    fragment?.Kind is QsFragmentKind.OperationDeclaration operation ? GetCharacteristics(operation.Item3.Argument) :
+                    fragment?.Kind is QsFragmentKind.TypeDefinition type ? GetCharacteristics(type.Item3) :
                     Enumerable.Empty<Characteristics>();
 
                 //var symbolInfo = file.TryGetQsSymbolInfo(d.Range.Start, false, out var fragment);
@@ -294,10 +303,25 @@ static IEnumerable<Characteristics> GetCharacteristics(QsTuple<Tuple<QsSymbol, Q
         internal static IEnumerable<(string, WorkspaceEdit)> SuggestionsForIndexRange
             (this FileContentManager file, CompilationUnit compilation, LSP.Range range)
         {
-            if (file == null || compilation == null || range?.Start == null) return Enumerable.Empty<(string, WorkspaceEdit)>();
-            var indexRangeNamespaces = compilation.GlobalSymbols.NamespacesContainingCallable(BuiltIn.IndexRange.FullName.Name);
-            if (!indexRangeNamespaces.Contains(BuiltIn.IndexRange.FullName.Namespace)) return Enumerable.Empty<(string, WorkspaceEdit)>();
-            var suggestedOpenDir = file.OpenDirectiveSuggestions(range.Start.Line, BuiltIn.IndexRange.FullName.Namespace);
+            if (file == null || compilation == null || range?.Start == null)
+            {
+                return Enumerable.Empty<(string, WorkspaceEdit)>();
+            }
+
+            // Ensure that the IndexRange library function exists in this compilation unit.
+            var nsName = file.TryGetNamespaceAt(range.Start);
+            if (nsName == null)
+            {
+                return Enumerable.Empty<(string, WorkspaceEdit)>();
+            }
+            var indexRange = compilation.GlobalSymbols.TryGetCallable(
+                new QsQualifiedName(BuiltIn.IndexRange.FullName.Namespace, BuiltIn.IndexRange.FullName.Name),
+                NonNullable<string>.New(nsName),
+                file.FileName);
+            if (!indexRange.IsFound)
+            {
+                return Enumerable.Empty<(string, WorkspaceEdit)>();
+            }
 
             /// Returns true the given expression is of the form "0 .. Length(args) - 1",
             /// as well as the range of the entire expression and the argument tuple "(args)" as out parameters.
@@ -343,8 +367,9 @@ static IEnumerable<TextEdit> IndexRangeEdits(CodeFragment fragment)
 
             var fragments = file.FragmentsOverlappingWithRange(range);
             var edits = fragments.SelectMany(IndexRangeEdits);
-            return edits.Any()
-                ? new[] { ("Use IndexRange to iterate over indices.", file.GetWorkspaceEdit(suggestedOpenDir.Concat(edits).ToArray())) }
+            var suggestedOpenDir = file.OpenDirectiveSuggestions(range.Start.Line, BuiltIn.IndexRange.FullName.Namespace);
+            return edits.Any() 
+                ? new[] { ("Use IndexRange to iterate over indices.", file.GetWorkspaceEdit(suggestedOpenDir.Concat(edits).ToArray())) } 
                 : Enumerable.Empty<(string, WorkspaceEdit)>();
         }
 
@@ -437,10 +462,11 @@ static bool EmptyOrFirstAttribute(IEnumerable<CodeFragment> line, out CodeFragme
             var docString = $"{docPrefix}# Summary{endLine}{docPrefix}{endLine}";
 
             var (argTuple, typeParams) =
-                callableDecl.IsValue ? (callableDecl.Item.Item2.Item2.Argument, callableDecl.Item.Item2.Item2.TypeParameters) :
-                typeDecl.IsValue ? (typeDecl.Item.Item2, ImmutableArray<QsSymbol>.Empty) :
-                (null, ImmutableArray<QsSymbol>.Empty);
-            var hasOutput = callableDecl.IsValue && !callableDecl.Item.Item2.Item2.ReturnType.Type.IsUnitType;
+                callableDecl.IsValue ? (callableDecl.Item.Item2.Item3.Argument,
+                                        callableDecl.Item.Item2.Item3.TypeParameters)
+                : typeDecl.IsValue ? (typeDecl.Item.Item2.Item2, ImmutableArray<QsSymbol>.Empty)
+                : (null, ImmutableArray<QsSymbol>.Empty);
+            var hasOutput = callableDecl.IsValue && !callableDecl.Item.Item2.Item3.ReturnType.Type.IsUnitType;
 
             var args = argTuple == null ? ImmutableArray<Tuple<QsSymbol, QsType>>.Empty : SyntaxGenerator.ExtractItems(argTuple);
             docString = String.Concat(

src/QsCompiler/CompilationManager/EditorSupport/CodeCompletion.cs

@@ -3,6 +3,7 @@
 
 using Microsoft.Quantum.QsCompiler.CompilationBuilder.DataStructures;
 using Microsoft.Quantum.QsCompiler.DataTypes;
+using Microsoft.Quantum.QsCompiler.SymbolManagement;
 using Microsoft.Quantum.QsCompiler.SyntaxProcessing;
 using Microsoft.Quantum.QsCompiler.SyntaxTokens;
 using Microsoft.Quantum.QsCompiler.SyntaxTree;
@@ -310,7 +311,8 @@ private static IEnumerable<CompletionItem> GetLocalCompletions(
         }
 
         /// <summary>
-        /// Returns completions for all callables visible given the current namespace and the list of open namespaces.
+        /// Returns completions for all accessible callables given the current namespace and the list of open
+        /// namespaces, or an empty enumerable if symbols haven't been resolved yet.
         /// </summary>
         /// <exception cref="ArgumentNullException">
         /// Thrown when any argument except <paramref name="currentNamespace"/> is null.
@@ -331,9 +333,9 @@ private static IEnumerable<CompletionItem> GetCallableCompletions(
             if (!compilation.GlobalSymbols.ContainsResolutions)
                 return Array.Empty<CompletionItem>();
             return
-                compilation.GlobalSymbols.DefinedCallables()
-                .Concat(compilation.GlobalSymbols.ImportedCallables())
-                .Where(callable => IsVisible(callable.QualifiedName, currentNamespace, openNamespaces))
+                compilation.GlobalSymbols.AccessibleCallables()
+                .Where(callable =>
+                    IsAccessibleAsUnqualifiedName(callable.QualifiedName, currentNamespace, openNamespaces))
                 .Select(callable => new CompletionItem()
                 {
                     Label = callable.QualifiedName.Name.Value,
@@ -348,7 +350,8 @@ private static IEnumerable<CompletionItem> GetCallableCompletions(
         }
 
         /// <summary>
-        /// Returns completions for all types visible given the current namespace and the list of open namespaces.
+        /// Returns completions for all accessible types given the current namespace and the list of open namespaces, or
+        /// an empty enumerable if symbols haven't been resolved yet.
         /// </summary>
         /// <exception cref="ArgumentNullException">
         /// Thrown when any argument except <paramref name="currentNamespace"/> is null.
@@ -369,9 +372,8 @@ private static IEnumerable<CompletionItem> GetTypeCompletions(
             if (!compilation.GlobalSymbols.ContainsResolutions)
                 return Array.Empty<CompletionItem>();
             return
-                compilation.GlobalSymbols.DefinedTypes()
-                .Concat(compilation.GlobalSymbols.ImportedTypes())
-                .Where(type => IsVisible(type.QualifiedName, currentNamespace, openNamespaces))
+                compilation.GlobalSymbols.AccessibleTypes()
+                .Where(type => IsAccessibleAsUnqualifiedName(type.QualifiedName, currentNamespace, openNamespaces))
                 .Select(type => new CompletionItem()
                 {
                     Label = type.QualifiedName.Name.Value,
@@ -385,7 +387,8 @@ private static IEnumerable<CompletionItem> GetTypeCompletions(
         }
 
         /// <summary>
-        /// Returns completions for all named items in any type.
+        /// Returns completions for all named items in any accessible type, or an empty enumerable if symbols haven't
+        /// been resolved yet.
         /// </summary>
         /// <exception cref="ArgumentNullException">Thrown when the argument is null.</exception>
         private static IEnumerable<CompletionItem> GetNamedItemCompletions(CompilationUnit compilation)
@@ -395,8 +398,7 @@ private static IEnumerable<CompletionItem> GetNamedItemCompletions(CompilationUn
 
             if (!compilation.GlobalSymbols.ContainsResolutions)
                 return Array.Empty<CompletionItem>();
-            return compilation.GlobalSymbols.DefinedTypes()
-                .Concat(compilation.GlobalSymbols.ImportedTypes())
+            return compilation.GlobalSymbols.AccessibleTypes()
                 .SelectMany(type => ExtractItems(type.TypeItems))
                 .Where(item => item.IsNamed)
                 .Select(item => new CompletionItem()
@@ -438,8 +440,8 @@ private static IEnumerable<CompletionItem> GetGlobalNamespaceCompletions(
         }
 
         /// <summary>
-        /// Returns completions for namespace aliases with the given prefix that are visible at the given position in
-        /// the file.
+        /// Returns completions for namespace aliases with the given prefix that are accessible from the given position
+        /// in the file.
         /// <para/>
         /// Note: a dot will be added after the given prefix if it is not the empty string, and doesn't already end with
         /// a dot.
@@ -499,9 +501,9 @@ private static string TryGetDocumentation(
             {
                 case CompletionItemKind.Function:
                 case CompletionItemKind.Constructor:
-                    var callable = compilation.GlobalSymbols.TryGetCallable(
+                    var result = compilation.GlobalSymbols.TryGetCallable(
                         data.QualifiedName, data.QualifiedName.Namespace, NonNullable<string>.New(data.SourceFile));
-                    if (callable.IsNull)
+                    if (!(result is ResolutionResult<CallableDeclarationHeader>.Found callable))
                         return null;
                     var signature = callable.Item.PrintSignature();
                     var documentation = callable.Item.Documentation.PrintSummary(useMarkdown);
@@ -510,15 +512,15 @@ private static string TryGetDocumentation(
                     var type =
                         compilation.GlobalSymbols.TryGetType(
                             data.QualifiedName, data.QualifiedName.Namespace, NonNullable<string>.New(data.SourceFile))
-                        .Item;
-                    return type?.Documentation.PrintSummary(useMarkdown).Trim();
+                        as ResolutionResult<TypeDeclarationHeader>.Found;
+                    return type?.Item.Documentation.PrintSummary(useMarkdown).Trim();
                 default:
                     return null;
             }
         }
 
         /// <summary>
-        /// Returns the names of all namespaces that have been opened without an alias and are visible from the given
+        /// Returns the names of all namespaces that have been opened without an alias and are accessible from the given
         /// position in the file. Returns an empty enumerator if the position is invalid.
         /// </summary>
         /// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
@@ -714,14 +716,15 @@ private static CompletionList ToCompletionList(this IEnumerable<CompletionItem>
             };
 
         /// <summary>
-        /// Returns true if the qualified name is visible given the current namespace and a list of open namespaces.
+        /// Returns true if the declaration with the given qualified name would be accessible if it was referenced using
+        /// its unqualified name, given the current namespace and a list of open namespaces.
         /// <para/>
-        /// Names that start with "_" are treated as "private"; they are only visible from the namespace in which they
-        /// are declared.
+        /// Note: Names that start with "_" are treated as "private;" they are only accessible from the namespace in
+        /// which they are declared.
         /// </summary>
-        private static bool IsVisible(QsQualifiedName qualifiedName,
-                                      string currentNamespace,
-                                      IEnumerable<string> openNamespaces) =>
+        private static bool IsAccessibleAsUnqualifiedName(QsQualifiedName qualifiedName,
+                                                          string currentNamespace,
+                                                          IEnumerable<string> openNamespaces) =>
             openNamespaces.Contains(qualifiedName.Namespace.Value) &&
             (!qualifiedName.Name.Value.StartsWith("_") || qualifiedName.Namespace.Value == currentNamespace);
     }

src/QsCompiler/CompilationManager/EditorSupport/EditorCommands.cs

@@ -7,6 +7,7 @@
 using System.Linq;
 using Microsoft.Quantum.QsCompiler.CompilationBuilder.DataStructures;
 using Microsoft.Quantum.QsCompiler.DataTypes;
+using Microsoft.Quantum.QsCompiler.SymbolManagement;
 using Microsoft.Quantum.QsCompiler.SyntaxProcessing;
 using Microsoft.Quantum.QsCompiler.SyntaxTokens;
 using Microsoft.Quantum.QsCompiler.SyntaxTree;
@@ -248,13 +249,28 @@ List<QsFunctor> FunctorApplications(ref QsExpression ex)
 
             // extracting and adapting the relevant information for the called callable
 
-            var ns = NonNullable<string>.New(nsName);
-            var methodDecl = id.Item1.Symbol is QsSymbolKind<QsSymbol>.Symbol sym
-                ? compilation.GlobalSymbols.TryResolveAndGetCallable(sym.Item, ns, file.FileName).Item1
-                : id.Item1.Symbol is QsSymbolKind<QsSymbol>.QualifiedSymbol qualSym
-                ? compilation.GlobalSymbols.TryGetCallable(new QsQualifiedName(qualSym.Item1, qualSym.Item2), ns, file.FileName)
-                : QsNullable<CallableDeclarationHeader>.Null;
-            if (methodDecl.IsNull) return null;
+            ResolutionResult<CallableDeclarationHeader>.Found methodDecl = null;
+            if (id.Item1.Symbol is QsSymbolKind<QsSymbol>.Symbol sym)
+            {
+                methodDecl =
+                    compilation.GlobalSymbols.TryResolveAndGetCallable(sym.Item,
+                                                                       NonNullable<string>.New(nsName),
+                                                                       file.FileName)
+                    as ResolutionResult<CallableDeclarationHeader>.Found;
+            }
+            else if (id.Item1.Symbol is QsSymbolKind<QsSymbol>.QualifiedSymbol qualSym)
+            {
+                methodDecl =
+                    compilation.GlobalSymbols.TryGetCallable(new QsQualifiedName(qualSym.Item1, qualSym.Item2),
+                                                             NonNullable<string>.New(nsName),
+                                                             file.FileName)
+                    as ResolutionResult<CallableDeclarationHeader>.Found;
+            }
+
+            if (methodDecl == null)
+            {
+                return null;
+            }
 
             var (documentation, argTuple) = (methodDecl.Item.Documentation, methodDecl.Item.ArgumentTuple);
             var nrCtlApplications = functors.Where(f => f.Equals(QsFunctor.Controlled)).Count();