Method checkModuleDeclaration

internal/checker/checker.go:5113–5201

(node *ast.Node)

}

func (c *Checker) checkModuleDeclaration(node *ast.Node) {
	if body := node.Body(); body != nil {
		c.checkSourceElement(body)
		if !ast.IsGlobalScopeAugmentation(node) {
			c.registerForUnusedIdentifiersCheck(node)
		}
	}
	isGlobalAugmentation := ast.IsGlobalScopeAugmentation(node)
	inAmbientContext := node.Flags&ast.NodeFlagsAmbient != 0
	if isGlobalAugmentation && !inAmbientContext {
		c.error(node.Name(), diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context)
	}
	isAmbientExternalModule := ast.IsAmbientModule(node)
	contextErrorMessage := core.IfElse(isAmbientExternalModule,
		diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file,
		diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module)
	if c.checkGrammarModuleElementContext(node, contextErrorMessage) {
		// If we hit a module declaration in an illegal context, just bail out to avoid cascading errors.
		return
	}
	if !c.checkGrammarModifiers(node) {
		if !inAmbientContext && ast.IsStringLiteral(node.Name()) {
			c.grammarErrorOnNode(node.Name(), diagnostics.Only_ambient_modules_can_use_quoted_names)
		}
	}
	if ast.IsIdentifier(node.Name()) {
		c.checkCollisionsForDeclarationName(node, node.Name())
		if node.AsModuleDeclaration().Keyword == ast.KindModuleKeyword {
			c.error(node.Name(), diagnostics.A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead)
		}
	}
	c.checkExportsOnMergedDeclarations(node)
	symbol := c.getSymbolOfDeclaration(node)
	// The following checks only apply on a non-ambient instantiated module declaration.
	if symbol.Flags&ast.SymbolFlagsValueModule != 0 && !inAmbientContext && isInstantiatedModule(node, c.compilerOptions.ShouldPreserveConstEnums()) {
		if c.shouldCheckErasableSyntax(node) {
			c.error(node, diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled)
		}
		if c.compilerOptions.GetIsolatedModules() && ast.GetSourceFileOfNode(node).ExternalModuleIndicator == nil {
			// This could be loosened a little if needed. The only problem we are trying to avoid is unqualified
			// references to namespace members declared in other files. But use of namespaces is discouraged anyway,
			// so for now we will just not allow them in scripts, which is the only place they can merge cross-file.
			c.error(node.Name(), diagnostics.Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to_be_a_global_script_set_moduleDetection_to_force_or_add_an_empty_export_statement, c.getIsolatedModulesLikeFlagName())
		}
		if len(symbol.Declarations) > 1 {
			firstNonAmbientClassOrFunc := getFirstNonAmbientClassOrFunctionDeclaration(symbol)
			if firstNonAmbientClassOrFunc != nil {
				if ast.GetSourceFileOfNode(node) != ast.GetSourceFileOfNode(firstNonAmbientClassOrFunc) {
					c.error(node.Name(), diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged)
				} else if node.Pos() < firstNonAmbientClassOrFunc.Pos() {
					c.error(node.Name(), diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged)
				}
			}
		}
		if c.compilerOptions.VerbatimModuleSyntax.IsTrue() && ast.IsSourceFile(node.Parent) && node.ModifierFlags()&ast.ModifierFlagsExport != 0 && c.program.GetEmitModuleFormatOfFile(node.Parent.AsSourceFile()) == core.ModuleKindCommonJS {
			exportModifier := core.Find(node.ModifierNodes(), func(m *ast.Node) bool { return m.Kind == ast.KindExportKeyword })
			c.error(exportModifier, diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled)
		}