PRESUBMIT.py - chromium/src/base/allocator/partition_allocator - Git at Google

 # Copyright 2024 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """Chromium presubmit script for base/allocator/partition_allocator.

 See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
 for more details on the presubmit API built into depot_tools.
 """

 PRESUBMIT_VERSION = '2.0.0'

 # This is the base path of the partition_alloc directory when stored inside the
 # chromium repository. PRESUBMIT.py is executed from chromium.
 _PARTITION_ALLOC_BASE_PATH = 'base/allocator/partition_allocator/src/'

 # Pattern matching C/C++ source files, for use in allowlist args.
 _SOURCE_FILE_PATTERN = r'.*\.(h|hpp|c|cc|cpp)$'

 # Similar pattern, matching GN files.
 _BUILD_FILE_PATTERN = r'.*\.(gn|gni)$'

 # This is adapted from Chromium's PRESUBMIT.py. The differences are:
 # - Base path: It is relative to the partition_alloc's source directory instead
 #              of chromium.
 # - Stricter: A single format is allowed: `PATH_ELEM_FILE_NAME_H_`.
 def CheckForIncludeGuards(input_api, output_api):
     """Check that header files have proper include guards"""

     def guard_for_file(file):
         local_path = file.LocalPath()
         if input_api.is_windows:
             local_path = local_path.replace('\\', '/')
         assert local_path.startswith(_PARTITION_ALLOC_BASE_PATH)
         guard = input_api.os_path.normpath(
             local_path[len(_PARTITION_ALLOC_BASE_PATH):])
         guard = guard + '_'
         guard = guard.upper()
         guard = input_api.re.sub(r'[+\\/.-]', '_', guard)
         return guard

     def is_partition_alloc_header_file(f):
         # We only check header files.
         return f.LocalPath().endswith('.h')

     errors = []

     for f in input_api.AffectedSourceFiles(is_partition_alloc_header_file):
         expected_guard = guard_for_file(f)

         # Unlike the Chromium's top-level PRESUBMIT.py, we enforce a stricter
         # rule which accepts only `PATH_ELEM_FILE_NAME_H_` per coding style.
         guard_name_pattern = input_api.re.escape(expected_guard)
         guard_pattern = input_api.re.compile(r'#ifndef\s+(' +
                                              guard_name_pattern + ')')

         guard_name = None
         guard_line_number = None
         seen_guard_end = False
         for line_number, line in enumerate(f.NewContents()):
             if guard_name is None:
                 match = guard_pattern.match(line)
                 if match:
                     guard_name = match.group(1)
                     guard_line_number = line_number
                 continue

             # The line after #ifndef should have a #define of the same name.
             if line_number == guard_line_number + 1:
                 expected_line = '#define %s' % guard_name
                 if line != expected_line:
                     errors.append(
                         output_api.PresubmitPromptWarning(
                             'Missing "%s" for include guard' % expected_line,
                             ['%s:%d' % (f.LocalPath(), line_number + 1)],
                             'Expected: %r\nGot: %r' % (expected_line, line)))

             if not seen_guard_end and line == '#endif  // %s' % guard_name:
                 seen_guard_end = True
                 continue

             if seen_guard_end:
                 if line.strip() != '':
                     errors.append(
                         output_api.PresubmitPromptWarning(
                             'Include guard %s not covering the whole file' %
                             (guard_name), [f.LocalPath()]))
                     break  # Nothing else to check and enough to warn once.

         if guard_name is None:
             errors.append(
                 output_api.PresubmitPromptWarning(
                     'Missing include guard in %s\n'
                     'Recommended name: %s\n' %
                     (f.LocalPath(), expected_guard)))

     return errors

 # In .gn and .gni files, check there are no unexpected dependencies on files
 # located outside of the partition_alloc repository.
 #
 # This is important, because partition_alloc has no CQ bots on its own, but only
 # through the chromium's CQ.
 #
 # Only //build_overrides/ is allowed, as it provides embedders, a way to
 # overrides the default build settings and forward the dependencies to
 # partition_alloc.
 def CheckNoExternalImportInGn(input_api, output_api):
     # Match and capture <path> from import("<path>").
     import_re = input_api.re.compile(r'^ *import\("([^"]+)"\)')

     sources = lambda affected_file: input_api.FilterSourceFile(
         affected_file,
         files_to_skip=[],
         files_to_check=[_BUILD_FILE_PATTERN])

     errors = []
     for f in input_api.AffectedSourceFiles(sources):
         for line_number, line in f.ChangedContents():
             match = import_re.search(line)
             if not match:
                 continue
             import_path = match.group(1)
             if import_path.startswith('//build_overrides/'):
                 continue
             if not import_path.startswith('//'):
                 continue;
             errors.append(output_api.PresubmitError(
                 '%s:%d\nPartitionAlloc disallow external import: %s' %
                 (f.LocalPath(), line_number + 1, import_path)))
     return errors;

 def CheckNoCpp23(input_api, output_api):
     """Checks that no C++23 features are used."""

     # 1. RAW_PATTERNS: (Regex Pattern, Feature Name).
     # These are for syntax features or complex matching needs.
     RAW_PATTERNS = [
         # C++23 consteval if statement
         (r'\bif\s+consteval\b', 'if consteval'),

         # C++23 preprocessor directives
         (r'^\s*#\s*elifdef\b', '#elifdef'),
         (r'^\s*#\s*elifndef\b', '#elifndef'),
         (r'^\s*#\s*warning\b', '#warning'),

         # C++23 standard library modules
         (r'\bimport\s+std\b', 'Standard Library Modules'),
         (r'\bimport\s+std\.compat\b', 'Standard Library Modules'),

         # C++23 deducing this
         (r'\bthis\s+auto\b', 'Deducing this (explicit object parameter)'),

         # C++23 size_t literal suffix
         (r'\b\d+(?:u|U)?(?:z|Z)(?:u|U)?\b', 'size_t literal suffix (z/Z)'),

         # C++23 [[assume(...)]] attribute
         (r'\[\[assume\(.*\)\]\]', '[[assume(...)]] attribute'),
     ]

     # 2. LIBRARY_SYMBOLS: Sequence[Symbol Name].
     # Those are only for library symbols added in C++23 accessible from
     # pre-c++23 headers.
     LIBRARY_SYMBOLS = [
         # <utility>, <bit>, <functional> additions
         'std::unreachable',
         'std::to_underlying',
         'std::byteswap',
         'std::forward_like',
         'std::move_only_function',
         'std::invoke_r',

         # <memory> additions:
         'std::start_lifetime_as',
         'std::start_lifetime_as_array',
         'std::out_ptr',
         'std::inout_ptr',
         'std::allocate_at_least',

         # <algorithm> or <ranges> additions:
         'std::ranges::to',
         'std::ranges::fold_left',
         'std::ranges::fold_right',
         'std::ranges::fold_left_first',
         'std::ranges::fold_right_last',
         'std::ranges::fold_left_with_iter',
         'std::ranges::contains',
         'views::zip',
         'views::zip_transform',
         'views::enumerate',
         'views::chunk',
         'views::chunk_by',
         'views::slide',
         'views::stride',
         'views::join_with',
         'views::adjacent',
         'views::adjacent_transform',
         'views::cartesian_product',
         'views::as_rvalue',
         'views::as_const',
         'views::repeat',
     ]

     compiled_checks = []

     for pattern, feature_name in RAW_PATTERNS:
         compiled_checks.append((input_api.re.compile(pattern), feature_name))

     for symbol in LIBRARY_SYMBOLS:
         pattern = r'\b' + input_api.re.escape(symbol) + r'\b'
         description = f'C++23 library symbol: {symbol}'
         compiled_checks.append((input_api.re.compile(pattern), description))

     sources = lambda affected_file: input_api.FilterSourceFile(
         affected_file,
         files_to_skip=[],
         files_to_check=[_SOURCE_FILE_PATTERN])

     errors = []
     for f in input_api.AffectedSourceFiles(sources):
         for line_number, line in enumerate(f.NewContents()):
             # Rudimentary comment stripping to check code only.
             line_no_comment = line.split('//')[0]

             for matcher, error_desc in compiled_checks:
                 if matcher.search(line_no_comment):
                     errors.append(
                         output_api.PresubmitError(
                             '%s:%d\nPartitionAlloc disallows C++23 feature: %s'
                             % (f.LocalPath(), line_number + 1, error_desc)))

     return errors

 # partition_alloc uses C++20.
 def CheckNoCpp23Features(input_api, output_api):
     CPP_23_PATTERNS = (
         r'#include <(expected|flat_map|flat_set|generator|mdspan|print|'
         r'spanstream|stacktrace|stdatomic.h|stdfloat)>',
         r'if !?consteval',
         r'^#elifn?def',
         r'std::byteswap',
         r'#warning',
         r'static.*operator(\(\)|\[\])',
         r'std::from_range',
         r'\[\[assume[^[]*\]\]',
         r'std::move_only_function',
         r'std::unreachable',
         r'std::(in)?out_ptr',
         r'std::start_lifetime_as',
         r'std::ranges::(contains|contains_subrange|starts_with|ends_with|'
         r'find_last|find_last_if|find_last_if_not|iota|shift_left|'
         r'shift_right|fold_left|fold_left_first|fold_right|fold_right_last|'
         r'fold_left_with_iter|fold_left_first_with_iter)',
         # C++23 range constructor for std::string_view (and u16/w variants)
         # constructed from a single identifier (excludes literals, function
         # calls, and multiple arguments).
         r'\bstd::(?:u16|w)?string_view\s*'
         r'(?:\(\s*([a-zA-Z_]\w*)\s*\)|\{\s*([a-zA-Z_]\w*)\s*\})',
     )

     sources = lambda affected_file: input_api.FilterSourceFile(
         affected_file,
         # compiler_specific.h may use these headers in guarded ways.
         files_to_skip=[
             r'.*partition_alloc_base/augmentations/compiler_specific\.h'
         ],
         files_to_check=[_SOURCE_FILE_PATTERN])

     errors = []
     for f in input_api.AffectedSourceFiles(sources):
         # for line_number, line in f.ChangedContents():
         for line_number, line in enumerate(f.NewContents()):
             for pattern in CPP_23_PATTERNS:
                 match = input_api.re.search(pattern, line)
                 if not match:
                     continue
                 errors.append(
                     output_api.PresubmitError(
                         '%s:%d\nPartitionAlloc disallows C++23 features: `%s`'
                         % (f.LocalPath(), line_number + 1, match.group(0))))
     return errors

 # Check `NDEBUG` is not used inside partition_alloc. We prefer to use the
 # buildflags `#if PA_BUILDFLAG(IS_DEBUG)` instead.
 def CheckNoNDebug(input_api, output_api):
     sources = lambda affected_file: input_api.FilterSourceFile(
         affected_file,
         files_to_skip=[],
         files_to_check=[_SOURCE_FILE_PATTERN])

     errors = []
     for f in input_api.AffectedSourceFiles(sources):
         for line_number, line in f.ChangedContents():
             if 'NDEBUG' in line:
                 errors.append(output_api.PresubmitError('%s:%d\nPartitionAlloc'
                   % (f.LocalPath(), line_number + 1)
                   + 'disallows NDEBUG, use PA_BUILDFLAG(IS_DEBUG) instead'))
     return errors


 def CheckUnexpectedPreprocessorDefines(input_api, output_api):
     """
     Checks partition_alloc doesn't depend on chrome's specific definitions.
     """

     # Macros that are allowed to be used with defined(...)
     ALLOWED_DEFINITIONS = {
         # Compiler built-ins
         'ADDRESS_SANITIZER',
         'MEMORY_SANITIZER',
         'THREAD_SANITIZER',
         '_CPPUNWIND',
         '_MSC_VER',
         '_WIN32',
         '_WIN64',
         '__AIX',
         '__APPLE__',
         '__ARMEL__',
         '__ARM_FEATURE_BTI_DEFAULT',
         '__ARM_FEATURE_MEMORY_TAGGING',
         '__EXCEPTIONS',
         '__GNUC__',
         '__LP64__',
         '__OBJC__',
         '__arm__',
         '__clang__',
         '__clang_analyzer__',
         '__cpp_constexpr',
         '__cpp_lib_atomic_value_initialization',
         '__cpp_lib_three_way_comparison',
         '__has_attribute',
         '__has_builtin',
         '__has_cpp_attribute',
         '__has_extension',
         '__has_feature',
         '__has_warning',
         '__i386__',
         '__pic__',

         # System/Library macros
         'RTLD_DEEPBIND',
         '_GNU_SOURCE',
         '_POSIX_MONOTONIC_CLOCK',
         '_POSIX_THREAD_CPUTIME',
         '_SC_PAGESIZE',
         'PR_SET_VMA',
         'PR_SET_VMA_ANON_NAME',
         '__BIONIC__',
         '__GLIBC_PREREQ',
         '__GLIBC__',
         '__MALLOC_HOOK_VOLATILE',
         '__NR_mseal',
         '__UCLIBC__',
         '_MIPS_ARCH_LOONGSON',

         # Gtest
         'GTEST_HAS_DEATH_TEST',

         # TODO - The following macros are defined outside of partition_alloc and
         # should be removed/replaced with PA_BUILDFLAG or PA_CONFIG at some
         # point.
         'HAS_HW_CAPS',
         'HAVE_BACKTRACE',
         'LINUX_NAME_REGION',
         'NDEBUG',
         'NEEDS_HANDLING_OF_HW_CAPABILITIES',
     }
     target_path_prefix = (
         'base/allocator/partition_allocator/src/partition_alloc/')

     def is_relevant_file(f):
         path = f.LocalPath().replace('\\', '/')
         if path.endswith('/build_config.h'):
             return False
         # Exclude tests
         if any(x in path for x in
                ('unittest', 'perftest', '/test/', '_unittest')):
             return False
         return (path.startswith(target_path_prefix) and
                 path.endswith(('.h', '.cc', '.S', '.mm')))

     defined_regex = input_api.re.compile(r'defined\(\s*(\w+)\s*\)')

     errors = []

     for f in input_api.AffectedSourceFiles(is_relevant_file):
         for line_number, line in f.ChangedContents():
             matches = defined_regex.findall(line)
             for macro in matches:
                 # Automatically allow any PartitionAlloc internal macros
                 if macro.startswith((
                         'PA_',
                         'PARTITION_ALLOC_',
                         'PARTITION_ALLOCATOR_',
                         'PAGE_ALLOCATOR_',
                 )):
                     continue

                 # Ignore header guards
                 file_name = input_api.os_path.basename(f.LocalPath())
                 file_guard_part = file_name.upper().replace('.', '_') + '_'
                 if macro.endswith('_H_') and (
                         file_guard_part in macro or
                         macro.startswith('PARTITION_ALLOC_')):
                     continue

                 if macro in ALLOWED_DEFINITIONS:
                     continue

                 errors.append(
                     output_api.PresubmitError(
                         f'Unexpected macro `{macro}` in `defined()` in '
                         f'{f.LocalPath()}:{line_number}.\n'
                         f'If this is a new macro, please add it to the '
                         f'allowed list in PRESUBMIT.py if it is a '
                         f'compiler/system built-in.\n'
                         f'Otherwise, use PA_BUILDFLAG or PA_CONFIG '
                         f'instead.',
                         items=[f'{f.LocalPath()}:{line_number}: {line}']
                     )
                 )

     return errors
	# Copyright 2024 The Chromium Authors
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.
	"""Chromium presubmit script for base/allocator/partition_allocator.

	See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
	for more details on the presubmit API built into depot_tools.
	"""

	PRESUBMIT_VERSION = '2.0.0'

	# This is the base path of the partition_alloc directory when stored inside the
	# chromium repository. PRESUBMIT.py is executed from chromium.
	_PARTITION_ALLOC_BASE_PATH = 'base/allocator/partition_allocator/src/'

	# Pattern matching C/C++ source files, for use in allowlist args.
	_SOURCE_FILE_PATTERN = r'.*\.(h\|hpp\|c\|cc\|cpp)$'

	# Similar pattern, matching GN files.
	_BUILD_FILE_PATTERN = r'.*\.(gn\|gni)$'

	# This is adapted from Chromium's PRESUBMIT.py. The differences are:
	# - Base path: It is relative to the partition_alloc's source directory instead
	# of chromium.
	# - Stricter: A single format is allowed: `PATH_ELEM_FILE_NAME_H_`.
	def CheckForIncludeGuards(input_api, output_api):
	"""Check that header files have proper include guards"""

	def guard_for_file(file):
	local_path = file.LocalPath()
	if input_api.is_windows:
	local_path = local_path.replace('\\', '/')
	assert local_path.startswith(_PARTITION_ALLOC_BASE_PATH)
	guard = input_api.os_path.normpath(
	local_path[len(_PARTITION_ALLOC_BASE_PATH):])
	guard = guard + '_'
	guard = guard.upper()
	guard = input_api.re.sub(r'[+\\/.-]', '_', guard)
	return guard

	def is_partition_alloc_header_file(f):
	# We only check header files.
	return f.LocalPath().endswith('.h')

	errors = []

	for f in input_api.AffectedSourceFiles(is_partition_alloc_header_file):
	expected_guard = guard_for_file(f)

	# Unlike the Chromium's top-level PRESUBMIT.py, we enforce a stricter
	# rule which accepts only `PATH_ELEM_FILE_NAME_H_` per coding style.
	guard_name_pattern = input_api.re.escape(expected_guard)
	guard_pattern = input_api.re.compile(r'#ifndef\s+(' +
	guard_name_pattern + ')')

	guard_name = None
	guard_line_number = None
	seen_guard_end = False
	for line_number, line in enumerate(f.NewContents()):
	if guard_name is None:
	match = guard_pattern.match(line)
	if match:
	guard_name = match.group(1)
	guard_line_number = line_number
	continue

	# The line after #ifndef should have a #define of the same name.
	if line_number == guard_line_number + 1:
	expected_line = '#define %s' % guard_name
	if line != expected_line:
	errors.append(
	output_api.PresubmitPromptWarning(
	'Missing "%s" for include guard' % expected_line,
	['%s:%d' % (f.LocalPath(), line_number + 1)],
	'Expected: %r\nGot: %r' % (expected_line, line)))

	if not seen_guard_end and line == '#endif // %s' % guard_name:
	seen_guard_end = True
	continue

	if seen_guard_end:
	if line.strip() != '':
	errors.append(
	output_api.PresubmitPromptWarning(
	'Include guard %s not covering the whole file' %
	(guard_name), [f.LocalPath()]))
	break # Nothing else to check and enough to warn once.

	if guard_name is None:
	errors.append(
	output_api.PresubmitPromptWarning(
	'Missing include guard in %s\n'
	'Recommended name: %s\n' %
	(f.LocalPath(), expected_guard)))

	return errors

	# In .gn and .gni files, check there are no unexpected dependencies on files
	# located outside of the partition_alloc repository.
	#
	# This is important, because partition_alloc has no CQ bots on its own, but only
	# through the chromium's CQ.
	#
	# Only //build_overrides/ is allowed, as it provides embedders, a way to
	# overrides the default build settings and forward the dependencies to
	# partition_alloc.
	def CheckNoExternalImportInGn(input_api, output_api):
	# Match and capture <path> from import("<path>").
	import_re = input_api.re.compile(r'^ *import\("([^"]+)"\)')

	sources = lambda affected_file: input_api.FilterSourceFile(
	affected_file,
	files_to_skip=[],
	files_to_check=[_BUILD_FILE_PATTERN])

	errors = []
	for f in input_api.AffectedSourceFiles(sources):
	for line_number, line in f.ChangedContents():
	match = import_re.search(line)
	if not match:
	continue
	import_path = match.group(1)
	if import_path.startswith('//build_overrides/'):
	continue
	if not import_path.startswith('//'):
	continue;
	errors.append(output_api.PresubmitError(
	'%s:%d\nPartitionAlloc disallow external import: %s' %
	(f.LocalPath(), line_number + 1, import_path)))
	return errors;

	def CheckNoCpp23(input_api, output_api):
	"""Checks that no C++23 features are used."""

	# 1. RAW_PATTERNS: (Regex Pattern, Feature Name).
	# These are for syntax features or complex matching needs.
	RAW_PATTERNS = [
	# C++23 consteval if statement
	(r'\bif\s+consteval\b', 'if consteval'),

	# C++23 preprocessor directives
	(r'^\s#\selifdef\b', '#elifdef'),
	(r'^\s#\selifndef\b', '#elifndef'),
	(r'^\s#\swarning\b', '#warning'),

	# C++23 standard library modules
	(r'\bimport\s+std\b', 'Standard Library Modules'),
	(r'\bimport\s+std\.compat\b', 'Standard Library Modules'),

	# C++23 deducing this
	(r'\bthis\s+auto\b', 'Deducing this (explicit object parameter)'),

	# C++23 size_t literal suffix
	(r'\b\d+(?:u\|U)?(?:z\|Z)(?:u\|U)?\b', 'size_t literal suffix (z/Z)'),

	# C++23 [[assume(...)]] attribute
	(r'\[\[assume\(.*\)\]\]', '[[assume(...)]] attribute'),
	]

	# 2. LIBRARY_SYMBOLS: Sequence[Symbol Name].
	# Those are only for library symbols added in C++23 accessible from
	# pre-c++23 headers.
	LIBRARY_SYMBOLS = [
	# <utility>, <bit>, <functional> additions
	'std::unreachable',
	'std::to_underlying',
	'std::byteswap',
	'std::forward_like',
	'std::move_only_function',
	'std::invoke_r',

	# <memory> additions:
	'std::start_lifetime_as',
	'std::start_lifetime_as_array',
	'std::out_ptr',
	'std::inout_ptr',
	'std::allocate_at_least',

	# <algorithm> or <ranges> additions:
	'std::ranges::to',
	'std::ranges::fold_left',
	'std::ranges::fold_right',
	'std::ranges::fold_left_first',
	'std::ranges::fold_right_last',
	'std::ranges::fold_left_with_iter',
	'std::ranges::contains',
	'views::zip',
	'views::zip_transform',
	'views::enumerate',
	'views::chunk',
	'views::chunk_by',
	'views::slide',
	'views::stride',
	'views::join_with',
	'views::adjacent',
	'views::adjacent_transform',
	'views::cartesian_product',
	'views::as_rvalue',
	'views::as_const',
	'views::repeat',
	]

	compiled_checks = []

	for pattern, feature_name in RAW_PATTERNS:
	compiled_checks.append((input_api.re.compile(pattern), feature_name))

	for symbol in LIBRARY_SYMBOLS:
	pattern = r'\b' + input_api.re.escape(symbol) + r'\b'
	description = f'C++23 library symbol: {symbol}'
	compiled_checks.append((input_api.re.compile(pattern), description))

	sources = lambda affected_file: input_api.FilterSourceFile(
	affected_file,
	files_to_skip=[],
	files_to_check=[_SOURCE_FILE_PATTERN])

	errors = []
	for f in input_api.AffectedSourceFiles(sources):
	for line_number, line in enumerate(f.NewContents()):
	# Rudimentary comment stripping to check code only.
	line_no_comment = line.split('//')[0]

	for matcher, error_desc in compiled_checks:
	if matcher.search(line_no_comment):
	errors.append(
	output_api.PresubmitError(
	'%s:%d\nPartitionAlloc disallows C++23 feature: %s'
	% (f.LocalPath(), line_number + 1, error_desc)))

	return errors

	# partition_alloc uses C++20.
	def CheckNoCpp23Features(input_api, output_api):
	CPP_23_PATTERNS = (
	r'#include <(expected\|flat_map\|flat_set\|generator\|mdspan\|print\|'
	r'spanstream\|stacktrace\|stdatomic.h\|stdfloat)>',
	r'if !?consteval',
	r'^#elifn?def',
	r'std::byteswap',
	r'#warning',
	r'static.*operator(\(\)\|\[\])',
	r'std::from_range',
	r'\[\[assume[^[]*\]\]',
	r'std::move_only_function',
	r'std::unreachable',
	r'std::(in)?out_ptr',
	r'std::start_lifetime_as',
	r'std::ranges::(contains\|contains_subrange\|starts_with\|ends_with\|'
	r'find_last\|find_last_if\|find_last_if_not\|iota\|shift_left\|'
	r'shift_right\|fold_left\|fold_left_first\|fold_right\|fold_right_last\|'
	r'fold_left_with_iter\|fold_left_first_with_iter)',
	# C++23 range constructor for std::string_view (and u16/w variants)
	# constructed from a single identifier (excludes literals, function
	# calls, and multiple arguments).
	r'\bstd::(?:u16\|w)?string_view\s*'
	r'(?:\(\s([a-zA-Z_]\w)\s\)\|\{\s([a-zA-Z_]\w)\s\})',
	)

	sources = lambda affected_file: input_api.FilterSourceFile(
	affected_file,
	# compiler_specific.h may use these headers in guarded ways.
	files_to_skip=[
	r'.*partition_alloc_base/augmentations/compiler_specific\.h'
	],
	files_to_check=[_SOURCE_FILE_PATTERN])

	errors = []
	for f in input_api.AffectedSourceFiles(sources):
	# for line_number, line in f.ChangedContents():
	for line_number, line in enumerate(f.NewContents()):
	for pattern in CPP_23_PATTERNS:
	match = input_api.re.search(pattern, line)
	if not match:
	continue
	errors.append(
	output_api.PresubmitError(
	'%s:%d\nPartitionAlloc disallows C++23 features: `%s`'
	% (f.LocalPath(), line_number + 1, match.group(0))))
	return errors

	# Check `NDEBUG` is not used inside partition_alloc. We prefer to use the
	# buildflags `#if PA_BUILDFLAG(IS_DEBUG)` instead.
	def CheckNoNDebug(input_api, output_api):
	sources = lambda affected_file: input_api.FilterSourceFile(
	affected_file,
	files_to_skip=[],
	files_to_check=[_SOURCE_FILE_PATTERN])

	errors = []
	for f in input_api.AffectedSourceFiles(sources):
	for line_number, line in f.ChangedContents():
	if 'NDEBUG' in line:
	errors.append(output_api.PresubmitError('%s:%d\nPartitionAlloc'
	% (f.LocalPath(), line_number + 1)
	+ 'disallows NDEBUG, use PA_BUILDFLAG(IS_DEBUG) instead'))
	return errors


	def CheckUnexpectedPreprocessorDefines(input_api, output_api):
	"""
	Checks partition_alloc doesn't depend on chrome's specific definitions.
	"""

	# Macros that are allowed to be used with defined(...)
	ALLOWED_DEFINITIONS = {
	# Compiler built-ins
	'ADDRESS_SANITIZER',
	'MEMORY_SANITIZER',
	'THREAD_SANITIZER',
	'_CPPUNWIND',
	'_MSC_VER',
	'_WIN32',
	'_WIN64',
	'__AIX',
	'__APPLE__',
	'__ARMEL__',
	'__ARM_FEATURE_BTI_DEFAULT',
	'__ARM_FEATURE_MEMORY_TAGGING',
	'__EXCEPTIONS',
	'__GNUC__',
	'__LP64__',
	'__OBJC__',
	'__arm__',
	'__clang__',
	'__clang_analyzer__',
	'__cpp_constexpr',
	'__cpp_lib_atomic_value_initialization',
	'__cpp_lib_three_way_comparison',
	'__has_attribute',
	'__has_builtin',
	'__has_cpp_attribute',
	'__has_extension',
	'__has_feature',
	'__has_warning',
	'__i386__',
	'__pic__',

	# System/Library macros
	'RTLD_DEEPBIND',
	'_GNU_SOURCE',
	'_POSIX_MONOTONIC_CLOCK',
	'_POSIX_THREAD_CPUTIME',
	'_SC_PAGESIZE',
	'PR_SET_VMA',
	'PR_SET_VMA_ANON_NAME',
	'__BIONIC__',
	'__GLIBC_PREREQ',
	'__GLIBC__',
	'__MALLOC_HOOK_VOLATILE',
	'__NR_mseal',
	'__UCLIBC__',
	'_MIPS_ARCH_LOONGSON',

	# Gtest
	'GTEST_HAS_DEATH_TEST',

	# TODO - The following macros are defined outside of partition_alloc and
	# should be removed/replaced with PA_BUILDFLAG or PA_CONFIG at some
	# point.
	'HAS_HW_CAPS',
	'HAVE_BACKTRACE',
	'LINUX_NAME_REGION',
	'NDEBUG',
	'NEEDS_HANDLING_OF_HW_CAPABILITIES',
	}
	target_path_prefix = (
	'base/allocator/partition_allocator/src/partition_alloc/')

	def is_relevant_file(f):
	path = f.LocalPath().replace('\\', '/')
	if path.endswith('/build_config.h'):
	return False
	# Exclude tests
	if any(x in path for x in
	('unittest', 'perftest', '/test/', '_unittest')):
	return False
	return (path.startswith(target_path_prefix) and
	path.endswith(('.h', '.cc', '.S', '.mm')))

	defined_regex = input_api.re.compile(r'defined\(\s(\w+)\s\)')

	errors = []

	for f in input_api.AffectedSourceFiles(is_relevant_file):
	for line_number, line in f.ChangedContents():
	matches = defined_regex.findall(line)
	for macro in matches:
	# Automatically allow any PartitionAlloc internal macros
	if macro.startswith((
	'PA_',
	'PARTITION_ALLOC_',
	'PARTITION_ALLOCATOR_',
	'PAGE_ALLOCATOR_',
	)):
	continue

	# Ignore header guards
	file_name = input_api.os_path.basename(f.LocalPath())
	file_guard_part = file_name.upper().replace('.', '_') + '_'
	if macro.endswith('_H_') and (
	file_guard_part in macro or
	macro.startswith('PARTITION_ALLOC_')):
	continue

	if macro in ALLOWED_DEFINITIONS:
	continue

	errors.append(
	output_api.PresubmitError(
	f'Unexpected macro `{macro}` in `defined()` in '
	f'{f.LocalPath()}:{line_number}.\n'
	f'If this is a new macro, please add it to the '
	f'allowed list in PRESUBMIT.py if it is a '
	f'compiler/system built-in.\n'
	f'Otherwise, use PA_BUILDFLAG or PA_CONFIG '
	f'instead.',
	items=[f'{f.LocalPath()}:{line_number}: {line}']
	)
	)

	return errors