public FileSymbol()

in src/Bicep.Core/Semantics/FileSymbol.cs [20:141]
114 lines of code
20 McCabe index (conditional complexity)

        public FileSymbol(
            ISymbolContext context,
            BicepSourceFile sourceFile,
            NamespaceResolver namespaceResolver,
            LocalScope fileScope)
            : base(sourceFile.FileHandle.Uri)
        {
            this.Context = context;
            this.Syntax = sourceFile.ProgramSyntax;
            this.NamespaceResolver = namespaceResolver;
            this.FileKind = sourceFile.FileKind;
            this.LocalScopes = fileScope.ChildScopes;

            var declarationsBySyntax = ImmutableDictionary.CreateBuilder<SyntaxBase, DeclaredSymbol>();
            var extensionDeclarations = ImmutableArray.CreateBuilder<ExtensionNamespaceSymbol>();
            var extensionConfigAssignments = ImmutableArray.CreateBuilder<ExtensionConfigAssignmentSymbol>();
            var metadataDeclarations = ImmutableArray.CreateBuilder<MetadataSymbol>();
            var parameterDeclarations = ImmutableArray.CreateBuilder<ParameterSymbol>();
            var typeDeclarations = ImmutableArray.CreateBuilder<TypeAliasSymbol>();
            var variableDeclarations = ImmutableArray.CreateBuilder<VariableSymbol>();
            var functionDeclarations = ImmutableArray.CreateBuilder<DeclaredFunctionSymbol>();
            var resourceDeclarations = ImmutableArray.CreateBuilder<ResourceSymbol>();
            var moduleDeclarations = ImmutableArray.CreateBuilder<ModuleSymbol>();
            var outputDeclarations = ImmutableArray.CreateBuilder<OutputSymbol>();
            var assertDeclarations = ImmutableArray.CreateBuilder<AssertSymbol>();
            var parameterAssignments = ImmutableArray.CreateBuilder<ParameterAssignmentSymbol>();
            var testDeclarations = ImmutableArray.CreateBuilder<TestSymbol>();
            var importedTypes = ImmutableArray.CreateBuilder<ImportedTypeSymbol>();
            var importedVariables = ImmutableArray.CreateBuilder<ImportedVariableSymbol>();
            var importedFunctions = ImmutableArray.CreateBuilder<ImportedFunctionSymbol>();
            var erroredImports = ImmutableArray.CreateBuilder<ErroredImportSymbol>();
            var wildcardImports = ImmutableArray.CreateBuilder<WildcardImportSymbol>();

            foreach (var declaration in fileScope.Declarations)
            {
                declarationsBySyntax.Add(declaration.DeclaringSyntax, declaration);

                switch (declaration)
                {
                    case ExtensionNamespaceSymbol extensionNamespace:
                        extensionDeclarations.Add(extensionNamespace);

                        break;
                    case ExtensionConfigAssignmentSymbol extensionConfigAssignment:
                        extensionConfigAssignments.Add(extensionConfigAssignment);

                        break;
                    case MetadataSymbol metadata:
                        metadataDeclarations.Add(metadata);
                        break;
                    case ParameterSymbol parameter:
                        parameterDeclarations.Add(parameter);
                        break;
                    case TypeAliasSymbol typeAlias:
                        typeDeclarations.Add(typeAlias);
                        break;
                    case VariableSymbol variable:
                        variableDeclarations.Add(variable);
                        break;
                    case DeclaredFunctionSymbol declaredFunction:
                        functionDeclarations.Add(declaredFunction);
                        break;
                    case ResourceSymbol resource:
                        resourceDeclarations.Add(resource);
                        break;
                    case ModuleSymbol module:
                        moduleDeclarations.Add(module);
                        break;
                    case OutputSymbol output:
                        outputDeclarations.Add(output);
                        break;
                    case AssertSymbol assertion:
                        assertDeclarations.Add(assertion);
                        break;
                    case ParameterAssignmentSymbol parameterAssignment:
                        parameterAssignments.Add(parameterAssignment);
                        break;
                    case TestSymbol test:
                        testDeclarations.Add(test);
                        break;
                    case ImportedTypeSymbol importedType:
                        importedTypes.Add(importedType);
                        break;
                    case ImportedVariableSymbol importedVariable:
                        importedVariables.Add(importedVariable);
                        break;
                    case ImportedFunctionSymbol importedFunction:
                        importedFunctions.Add(importedFunction);
                        break;
                    case ErroredImportSymbol erroredImport:
                        erroredImports.Add(erroredImport);
                        break;
                    case WildcardImportSymbol wildcardImport:
                        wildcardImports.Add(wildcardImport);
                        break;
                }
            }

            DeclarationsBySyntax = declarationsBySyntax.ToImmutable();
            ExtensionDeclarations = extensionDeclarations.ToImmutable();
            ExtensionConfigAssignments = extensionConfigAssignments.ToImmutable();
            MetadataDeclarations = metadataDeclarations.ToImmutable();
            ParameterDeclarations = parameterDeclarations.ToImmutable();
            TypeDeclarations = typeDeclarations.ToImmutable();
            VariableDeclarations = variableDeclarations.ToImmutable();
            FunctionDeclarations = functionDeclarations.ToImmutable();
            ResourceDeclarations = resourceDeclarations.ToImmutable();
            ModuleDeclarations = moduleDeclarations.ToImmutable();
            OutputDeclarations = outputDeclarations.ToImmutable();
            AssertDeclarations = assertDeclarations.ToImmutable();
            ParameterAssignments = parameterAssignments.ToImmutable();
            TestDeclarations = testDeclarations.ToImmutable();
            ImportedTypes = importedTypes.ToImmutable();
            ImportedVariables = importedVariables.ToImmutable();
            ImportedFunctions = importedFunctions.ToImmutable();
            ErroredImports = erroredImports.ToImmutable();
            WildcardImports = wildcardImports.ToImmutable();

            this.declarationsByName = this.Declarations.ToLookup(decl => decl.Name, LanguageConstants.IdentifierComparer);

            this.usingDeclarationLazy = new Lazy<UsingDeclarationSyntax?>(() => this.Syntax.Children.OfType<UsingDeclarationSyntax>().FirstOrDefault());
        }