diff --git a/pkgs/ffigen/lib/src/header_parser/sub_parsers/compounddecl_parser.dart b/pkgs/ffigen/lib/src/header_parser/sub_parsers/compounddecl_parser.dart
index 23e01f33b1..8aa05b3572 100644
--- a/pkgs/ffigen/lib/src/header_parser/sub_parsers/compounddecl_parser.dart
+++ b/pkgs/ffigen/lib/src/header_parser/sub_parsers/compounddecl_parser.dart
@@ -136,7 +136,13 @@ Compound? _parseCompoundDeclaration(
     return null;
   }
 
-  final decl = Declaration(usr: usr, originalName: declName);
+  // For C++ compounds declared inside one or more scopes, [qualifiedName] is
+  // the fully-qualified name (e.g. `outer::Point` or `Outer::Inner`). At
+  // global scope it equals [declName].
+  final qualifiedName = declName.isEmpty
+      ? declName
+      : qualifiedNameFromUsr(usr, declName);
+  final decl = Declaration(usr: usr, originalName: qualifiedName);
   final Compound compound;
   if (declName.isEmpty) {
     cursor = context.cursorIndex.getDefinition(cursor);
@@ -155,12 +161,19 @@ Compound? _parseCompoundDeclaration(
   } else {
     cursor = context.cursorIndex.getDefinition(cursor);
     context.logger.fine(
-      '++++ Adding $className: Name: $declName, ${cursor.completeStringRepr()}',
+      '++++ Adding $className: Name: $qualifiedName, '
+      '${cursor.completeStringRepr()}',
     );
+    var dartName = configDecl.rename(decl);
+    if (dartName.contains('::')) {
+      // C++ scope separators are not valid in Dart identifiers. Flatten any
+      // scopes left after user renaming, preserving the renamed prefix if any.
+      dartName = flattenQualifiedName(dartName);
+    }
     compound = constructor(
       usr: usr,
-      originalName: declName,
-      name: configDecl.rename(decl),
+      originalName: qualifiedName,
+      name: dartName,
       dartDoc: getCursorDocComment(
         context,
         cursor,
diff --git a/pkgs/ffigen/lib/src/header_parser/sub_parsers/enumdecl_parser.dart b/pkgs/ffigen/lib/src/header_parser/sub_parsers/enumdecl_parser.dart
index ffd58fa9c5..1c6d8fbd73 100644
--- a/pkgs/ffigen/lib/src/header_parser/sub_parsers/enumdecl_parser.dart
+++ b/pkgs/ffigen/lib/src/header_parser/sub_parsers/enumdecl_parser.dart
@@ -55,7 +55,17 @@ EnumClass parseEnumDeclaration(clang_types.CXCursor cursor, Context context) {
         .where((c) => c.rawValue.startsWith('-'))
         .isNotEmpty;
   } else {
-    final decl = Declaration(usr: usr, originalName: enumName);
+    // For C++ enums declared inside one or more scopes, [qualifiedName] is the
+    // fully-qualified name (e.g. `outer::inner::Color` or
+    // `outer::Class::Color`). At global scope it equals [enumName].
+    final qualifiedName = qualifiedNameFromUsr(usr, enumName);
+    final decl = Declaration(usr: usr, originalName: qualifiedName);
+    var dartName = config.enums.rename(decl);
+    if (dartName.contains('::')) {
+      // C++ scope separators are not valid in Dart identifiers. Flatten any
+      // scopes left after user renaming, preserving the renamed prefix if any.
+      dartName = flattenQualifiedName(dartName);
+    }
     logger.fine('++++ Adding Enum: ${cursor.completeStringRepr()}');
     enumClass = EnumClass(
       usr: usr,
@@ -64,8 +74,8 @@ EnumClass parseEnumDeclaration(clang_types.CXCursor cursor, Context context) {
         cursor,
         availability: apiAvailability.dartDoc,
       ),
-      originalName: enumName,
-      name: config.enums.rename(decl),
+      originalName: qualifiedName,
+      name: dartName,
       nativeType: nativeType,
       context: context,
       apiAvailability: apiAvailability,
diff --git a/pkgs/ffigen/lib/src/header_parser/sub_parsers/var_parser.dart b/pkgs/ffigen/lib/src/header_parser/sub_parsers/var_parser.dart
index 6bd83d10ba..3924c82cc2 100644
--- a/pkgs/ffigen/lib/src/header_parser/sub_parsers/var_parser.dart
+++ b/pkgs/ffigen/lib/src/header_parser/sub_parsers/var_parser.dart
@@ -25,7 +25,19 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
     return bindingsIndex.getSeenVariableConstant(usr);
   }
 
-  final decl = Declaration(usr: usr, originalName: name);
+  // For C++ variables (and static data members) declared inside one or more
+  // scopes, [qualifiedName] is the fully-qualified name (e.g. `ns::nsVar` or
+  // `Box::member`). At file scope it equals [name].
+  final qualifiedName = qualifiedVarNameFromUsr(usr, name);
+  final decl = Declaration(usr: usr, originalName: qualifiedName);
+
+  // C++ scope separators are not valid in Dart identifiers. Flatten any scopes
+  // left after user renaming, preserving the renamed prefix if any.
+  final renamed = config.globals.rename(decl);
+  final dartName = renamed.contains('::')
+      ? flattenQualifiedName(renamed)
+      : renamed;
+
   final cType = cursor.type();
 
   // Try to evaluate as a constant first,
@@ -40,8 +52,8 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
         final value = clang.clang_EvalResult_getAsLongLong(evalResult);
         constant = Constant(
           usr: usr,
-          originalName: name,
-          name: config.globals.rename(decl),
+          originalName: qualifiedName,
+          name: dartName,
           dartDoc: getCursorDocComment(context, cursor),
           rawType: 'int',
           rawValue: value.toString(),
@@ -51,8 +63,8 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
         final value = clang.clang_EvalResult_getAsDouble(evalResult);
         constant = Constant(
           usr: usr,
-          originalName: name,
-          name: config.globals.rename(decl),
+          originalName: qualifiedName,
+          name: dartName,
           dartDoc: getCursorDocComment(context, cursor),
           rawType: 'double',
           rawValue: writeDoubleAsString(value),
@@ -63,8 +75,8 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
         final rawValue = getWrittenStringRepresentation(name, value, context);
         constant = Constant(
           usr: usr,
-          originalName: name,
-          name: config.globals.rename(decl),
+          originalName: qualifiedName,
+          name: dartName,
           dartDoc: getCursorDocComment(context, cursor),
           rawType: 'String',
           rawValue: "'$rawValue'",
@@ -100,8 +112,8 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
   }
 
   final global = Global(
-    originalName: name,
-    name: config.globals.rename(decl),
+    originalName: qualifiedName,
+    name: dartName,
     usr: usr,
     type: type,
     dartDoc: getCursorDocComment(context, cursor),
diff --git a/pkgs/ffigen/lib/src/header_parser/translation_unit_parser.dart b/pkgs/ffigen/lib/src/header_parser/translation_unit_parser.dart
index 8d4022f31d..fa0001f17a 100644
--- a/pkgs/ffigen/lib/src/header_parser/translation_unit_parser.dart
+++ b/pkgs/ffigen/lib/src/header_parser/translation_unit_parser.dart
@@ -23,7 +23,7 @@ Set<Binding> parseTranslationUnit(
   final logger = context.logger;
   final headers = <String, bool>{};
 
-  translationUnitCursor.visitChildren((cursor) {
+  void rootCursorVisitor(clang_types.CXCursor cursor) {
     final file = cursor.sourceFileName();
     if (file.isEmpty) return;
     if (headers[file] ??= context.config.headers.include(Uri.file(file))) {
@@ -33,8 +33,11 @@ Set<Binding> parseTranslationUnit(
           case clang_types.CXCursorKind.CXCursor_FunctionDecl:
             bindings.addAll(parseFunctionDeclaration(context, cursor));
             break;
-          case clang_types.CXCursorKind.CXCursor_StructDecl:
           case clang_types.CXCursorKind.CXCursor_UnionDecl:
+          case clang_types.CXCursorKind.CXCursor_StructDecl:
+            addToBindings(bindings, _getCodeGenTypeFromCursor(context, cursor));
+            _visitRecordForNestedDecls(context, cursor, bindings, headers);
+            break;
           case clang_types.CXCursorKind.CXCursor_EnumDecl:
           case clang_types.CXCursorKind.CXCursor_ObjCInterfaceDecl:
           case clang_types.CXCursorKind.CXCursor_TypedefDecl:
@@ -60,6 +63,16 @@ Set<Binding> parseTranslationUnit(
             break;
           case clang_types.CXCursorKind.CXCursor_ClassDecl:
             addToBindings(bindings, parseClassDeclaration(context, cursor));
+            _visitRecordForNestedDecls(context, cursor, bindings, headers);
+            break;
+          case clang_types.CXCursorKind.CXCursor_Namespace:
+            _visitNamespaceForNestedDecls(context, cursor, bindings, headers);
+            break;
+          case clang_types.CXCursorKind.CXCursor_LinkageSpec:
+            // Declarations inside `extern "C" { ... }` blocks are wrapped in
+            // a LinkageSpec cursor when parsing in C++ mode. Recurse into it
+            // so they're dispatched like top-level declarations.
+            cursor.visitChildren(rootCursorVisitor);
             break;
           default:
             logger.finer('rootCursorVisitor: CursorKind not implemented');
@@ -74,7 +87,9 @@ Set<Binding> parseTranslationUnit(
         'rootCursorVisitor:(not included) ${cursor.completeStringRepr()}',
       );
     }
-  });
+  }
+
+  translationUnitCursor.visitChildren(rootCursorVisitor);
 
   return bindings;
 }
@@ -87,6 +102,100 @@ void addToBindings(Set<Binding> bindings, Binding? b) {
   }
 }
 
+/// Recurses into a C++ namespace, surfacing enum, struct, union and variable
+/// (including constant) declarations.
+// TODO: Dispatch ClassDecl, FunctionDecl, etc. here for full C++ namespace
+// support. Class declarations are currently visited only to find nested
+// enums, structs, unions and static data members.
+void _visitNamespaceForNestedDecls(
+  Context context,
+  clang_types.CXCursor namespaceCursor,
+  Set<Binding> bindings,
+  Map<String, bool> headers,
+) {
+  final logger = context.logger;
+  if (clang.clang_Cursor_isAnonymous(namespaceCursor) != 0) {
+    logger.fine('Skipping anonymous namespace.');
+    return;
+  }
+  _visitChildrenForNestedDecls(context, namespaceCursor, bindings, headers);
+}
+
+/// Recurses into a C++ record to surface enum, struct and union declarations,
+/// and static data members (e.g. `static constexpr` constants), nested inside
+/// it.
+void _visitRecordForNestedDecls(
+  Context context,
+  clang_types.CXCursor recordCursor,
+  Set<Binding> bindings,
+  Map<String, bool> headers,
+) {
+  final logger = context.logger;
+  if (clang.clang_Cursor_isAnonymous(recordCursor) != 0) {
+    logger.fine('Skipping anonymous record.');
+    return;
+  }
+  _visitChildrenForNestedDecls(context, recordCursor, bindings, headers);
+}
+
+void _visitChildrenForNestedDecls(
+  Context context,
+  clang_types.CXCursor parentCursor,
+  Set<Binding> bindings,
+  Map<String, bool> headers,
+) {
+  final logger = context.logger;
+  parentCursor.visitChildren((cursor) {
+    final file = cursor.sourceFileName();
+    if (file.isEmpty) return;
+    if (!(headers[file] ??= context.config.headers.include(Uri.file(file)))) {
+      logger.finest(
+        'nestedDeclCursorVisitor:(not included) ${cursor.completeStringRepr()}',
+      );
+      return;
+    }
+    try {
+      logger.finest('nestedDeclCursorVisitor: ${cursor.completeStringRepr()}');
+      switch (clang.clang_getCursorKind(cursor)) {
+        case clang_types.CXCursorKind.CXCursor_Namespace:
+          _visitNamespaceForNestedDecls(context, cursor, bindings, headers);
+          break;
+        case clang_types.CXCursorKind.CXCursor_LinkageSpec:
+          // Recurse into `extern "C" { ... }` blocks.
+          _visitChildrenForNestedDecls(context, cursor, bindings, headers);
+          break;
+        case clang_types.CXCursorKind.CXCursor_UnionDecl:
+        case clang_types.CXCursorKind.CXCursor_StructDecl:
+          // Anonymous records are handled as members of their parent record,
+          // not as top-level bindings.
+          if (clang.clang_Cursor_isAnonymous(cursor) == 0) {
+            addToBindings(bindings, _getCodeGenTypeFromCursor(context, cursor));
+          }
+          _visitRecordForNestedDecls(context, cursor, bindings, headers);
+          break;
+        case clang_types.CXCursorKind.CXCursor_ClassDecl:
+          _visitRecordForNestedDecls(context, cursor, bindings, headers);
+          break;
+        case clang_types.CXCursorKind.CXCursor_EnumDecl:
+          addToBindings(bindings, _getCodeGenTypeFromCursor(context, cursor));
+          break;
+        case clang_types.CXCursorKind.CXCursor_VarDecl:
+          // A namespace-scoped variable or a static data member (e.g. a
+          // `static constexpr` constant). Non-static instance fields are
+          // FieldDecl, not VarDecl, so they aren't surfaced here.
+          addToBindings(bindings, parseVarDeclaration(context, cursor));
+          break;
+        default:
+          logger.finer('nestedDeclCursorVisitor: CursorKind not implemented');
+      }
+    } catch (e, s) {
+      logger.severe(e);
+      logger.severe(s);
+      rethrow;
+    }
+  });
+}
+
 BindingType? _getCodeGenTypeFromCursor(
   Context context,
   clang_types.CXCursor cursor,
@@ -101,13 +210,22 @@ void buildUsrCursorDefinitionMap(
   clang_types.CXCursor translationUnitCursor,
 ) {
   final logger = context.logger;
-  translationUnitCursor.visitChildren((cursor) {
+  void visitor(clang_types.CXCursor cursor) {
     try {
-      context.cursorIndex.saveDefinition(cursor);
+      if (clang.clang_getCursorKind(cursor) ==
+          clang_types.CXCursorKind.CXCursor_LinkageSpec) {
+        // Declarations inside `extern "C" { ... }` blocks are wrapped in a
+        // LinkageSpec cursor when parsing in C++ mode.
+        cursor.visitChildren(visitor);
+      } else {
+        context.cursorIndex.saveDefinition(cursor);
+      }
     } catch (e, s) {
       logger.severe(e);
       logger.severe(s);
       rethrow;
     }
-  });
+  }
+
+  translationUnitCursor.visitChildren(visitor);
 }
diff --git a/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart b/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart
index 484b38eca0..08a0fa8958 100644
--- a/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart
+++ b/pkgs/ffigen/lib/src/header_parser/type_extractor/extractor.dart
@@ -130,9 +130,18 @@ Type getCodeGenType(
       return BooleanType();
     case clang_types.CXTypeKind.CXType_Attributed:
     case clang_types.CXTypeKind.CXType_Unexposed:
+      // For attributed types, the modified type is the underlying type. Other
+      // unexposed types (e.g. a C++ type referenced through a
+      // using-declaration, like `std::uint16_t`) have no modified type;
+      // resolve those via their canonical type instead.
+      var innerCxType = clang.clang_Type_getModifiedType(cxtype);
+      if (innerCxType.kind == clang_types.CXTypeKind.CXType_Invalid) {
+        final canonical = clang.clang_getCanonicalType(cxtype);
+        if (canonical.kind != cxtype.kind) innerCxType = canonical;
+      }
       final innerType = getCodeGenType(
         context,
-        clang.clang_Type_getModifiedType(cxtype),
+        innerCxType,
         originalCursor: originalCursor,
       );
       final isNullable =
diff --git a/pkgs/ffigen/lib/src/header_parser/utils.dart b/pkgs/ffigen/lib/src/header_parser/utils.dart
index b7aefa6a4a..f910ba1fdf 100644
--- a/pkgs/ffigen/lib/src/header_parser/utils.dart
+++ b/pkgs/ffigen/lib/src/header_parser/utils.dart
@@ -110,7 +110,10 @@ extension CXCursorExt on clang_types.CXCursor {
 
   String usr() {
     var res = clang.clang_getCursorUSR(this).toStringAndDispose();
-    assert(!res.contains(synthUsrChar));
+    // Raw USRs must not collide with the synthesized `~ <label>:` suffixes
+    // added below and elsewhere. A bare [synthUsrChar] can legitimately appear
+    // in a raw USR, e.g. in a C++ destructor name like `@F@~Foo#`.
+    assert(!res.contains('$synthUsrChar '));
     if (isAnonymousRecordDecl()) {
       res += '$synthUsrChar anonRec: offset:${sourceFileOffset()}';
     }
@@ -729,3 +732,54 @@ String _getWritableChar(int char, {bool utf8 = true}) {
   /// In all other cases, simply convert to string.
   return String.fromCharCode(char);
 }
+
+/// Builds the fully-qualified C++ name of a declaration from its [usr].
+///
+/// A USR like `c:@N@outer@S@Palette@E@Tone` yields
+/// `outer::Palette::Tone`. At global scope (no enclosing namespace or class)
+/// this just returns [leafName].
+String qualifiedNameFromUsr(String usr, String leafName) {
+  // After the `c:` prefix, USR tokens alternate between a single-char kind
+  // marker (`N` for namespace, `S` for class/struct, `U` for union, `E` for
+  // enum, etc.) and its name. Collect the names of the enclosing scopes by
+  // stepping over each marker/name pair, skipping the last pair which is the
+  // declaration itself.
+  final parts = usr.split('@');
+  final scopes = <String>[];
+  for (var i = 1; i + 3 < parts.length; i += 2) {
+    if (parts[i] == 'N' || parts[i] == 'S' || parts[i] == 'U') {
+      scopes.add(parts[i + 1]);
+    }
+  }
+  if (scopes.isEmpty) return leafName;
+  return [...scopes, leafName].join('::');
+}
+
+/// Builds the fully-qualified C++ name of a variable (or static data member)
+/// from its [usr].
+///
+/// Unlike [qualifiedNameFromUsr], a variable's USR ends in a bare name token
+/// with no preceding kind marker, e.g. `c:@N@ns@nsInt` or `c:@S@Box@memberInt`
+/// (const variables also carry a leading file token, e.g.
+/// `c:foo.h@N@ns@nsInt`). These yield `ns::nsInt` and `Box::memberInt`
+/// respectively. At file scope (no enclosing namespace or class) this just
+/// returns [leafName].
+String qualifiedVarNameFromUsr(String usr, String leafName) {
+  // Scope markers/names sit between the `c:`(+file) prefix (parts[0]) and the
+  // trailing leaf token (parts.last), alternating marker/name.
+  final parts = usr.split('@');
+  final scopes = <String>[];
+  for (var i = 1; i + 1 < parts.length; i += 2) {
+    if (parts[i] == 'N' || parts[i] == 'S' || parts[i] == 'U') {
+      scopes.add(parts[i + 1]);
+    }
+  }
+  if (scopes.isEmpty) return leafName;
+  return [...scopes, leafName].join('::');
+}
+
+/// Flattens a `::`-qualified C++ name into a single Dart identifier by joining
+/// the path segments with `$`, e.g. `outer::inner::Color` becomes
+/// `outer$inner$Color`.
+String flattenQualifiedName(String qualifiedName) =>
+    qualifiedName.split('::').where((s) => s.isNotEmpty).join(r'$');
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test.dart b/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test.dart
new file mode 100644
index 0000000000..0c0bc101a8
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test.dart
@@ -0,0 +1,39 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test/test.dart';
+
+import 'cpp_constexpr_test_bindings.dart';
+
+void main() {
+  group('CppConstexpr', () {
+    test('top-level constexpr constants', () {
+      expect(topInt, 5);
+      expect(topDouble, 3.5);
+      expect(topStr, 'hello');
+      expect(topDerived, 10);
+    });
+
+    test('constexpr in a namespace', () {
+      expect(ns$nsInt, 42);
+    });
+
+    test('constexpr in a nested namespace', () {
+      expect(ns$inner$nsInt, 43);
+    });
+
+    test('static constexpr member of a struct', () {
+      expect(Box$memberInt, 7);
+      expect(Box$memberDouble, 2.5);
+    });
+
+    test('static constexpr member of a class', () {
+      expect(Widget$classInt, 99);
+    });
+
+    test('static constexpr member of a class in a namespace', () {
+      expect(scoped$Gadget$gadgetInt, 100);
+    });
+  });
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test.h b/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test.h
new file mode 100644
index 0000000000..f336404a39
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Top-level constexpr constants of various types.
+constexpr int topInt = 5;
+constexpr double topDouble = 3.5;
+constexpr const char* topStr = "hello";
+
+// A constexpr that references another constexpr in its initializer.
+constexpr int topDerived = topInt * 2;
+
+namespace ns {
+// Constexpr in a namespace.
+constexpr int nsInt = 42;
+
+namespace inner {
+// Constexpr in a nested namespace. Shares the leaf name `nsInt` with
+// `ns::nsInt` to exercise leaf-name collisions.
+constexpr int nsInt = 43;
+}  // namespace inner
+}  // namespace ns
+
+struct Box {
+  // Static constexpr data member of a struct. Non-static fields (like `size`)
+  // are not constants and must not be surfaced as such.
+  static constexpr int memberInt = 7;
+  static constexpr double memberDouble = 2.5;
+  int size;
+};
+
+class Widget {
+ public:
+  // Static constexpr data member of a class.
+  static constexpr int classInt = 99;
+};
+
+namespace scoped {
+class Gadget {
+ public:
+  // Static constexpr data member of a class nested in a namespace.
+  static constexpr int gadgetInt = 100;
+};
+}  // namespace scoped
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test_bindings.dart b/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test_bindings.dart
new file mode 100644
index 0000000000..540ada9aca
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_constexpr_test_bindings.dart
@@ -0,0 +1,24 @@
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `package:ffigen`.
+// ignore_for_file: type=lint, unused_import, unused_element, deprecated_member_use_from_same_package
+
+const double Box$memberDouble = 2.5;
+
+const int Box$memberInt = 7;
+
+const int Widget$classInt = 99;
+
+const int ns$inner$nsInt = 43;
+
+const int ns$nsInt = 42;
+
+const int scoped$Gadget$gadgetInt = 100;
+
+const int topDerived = 10;
+
+const double topDouble = 3.5;
+
+const int topInt = 5;
+
+const String topStr = 'hello';
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test.dart b/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test.dart
new file mode 100644
index 0000000000..f4baba1767
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test.dart
@@ -0,0 +1,27 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test/test.dart';
+
+import 'cpp_extern_c_test_bindings.dart';
+
+void main() {
+  group('CppExternC', () {
+    test('declarations inside extern "C" blocks are generated', () {
+      expect(Fruit, isNotNull);
+      expect(Pair, isNotNull);
+      expect(Number, isNotNull);
+    });
+
+    test('enum inside an extern "C" block', () {
+      expect(Fruit.apple.value, 1);
+      expect(Fruit.banana.value, 2);
+    });
+
+    test('enum inside an extern "C" block in a namespace', () {
+      expect(ns$Flag.off.value, 0);
+      expect(ns$Flag.on.value, 1);
+    });
+  });
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test.h b/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test.h
new file mode 100644
index 0000000000..83e01ceccf
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test.h
@@ -0,0 +1,42 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+extern "C" {
+
+enum Fruit { apple = 1, banana = 2 };
+
+struct Pair {
+  int a;
+  int b;
+};
+
+union Number {
+  int i;
+  float f;
+};
+
+int add(int a, int b);
+
+extern int counter;
+
+// A linkage spec nested inside another linkage spec.
+extern "C" {
+int deep(void);
+}
+
+}  // extern "C"
+
+// Single-declaration form, without braces.
+extern "C" void reset(void);
+
+// A linkage spec nested inside a namespace.
+namespace ns {
+extern "C" {
+enum Flag { off = 0, on = 1 };
+}
+}  // namespace ns
+
+// A declaration outside any linkage spec, to check that regular declarations
+// still parse alongside `extern "C"` blocks.
+int outside(double d);
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test_bindings.dart b/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test_bindings.dart
new file mode 100644
index 0000000000..8b17b83450
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_extern_c_test_bindings.dart
@@ -0,0 +1,72 @@
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `package:ffigen`.
+// ignore_for_file: type=lint, unused_import, unused_element, deprecated_member_use_from_same_package
+import 'dart:ffi' as ffi;
+
+@ffi.Native<ffi.Int Function(ffi.Int, ffi.Int)>()
+external int add(int a, int b);
+
+@ffi.Native<ffi.Int>()
+external int counter;
+
+@ffi.Native<ffi.Int Function()>()
+external int deep();
+
+@ffi.Native<ffi.Int Function(ffi.Double)>()
+external int outside(double d);
+
+@ffi.Native<ffi.Void Function()>()
+external void reset();
+
+enum Fruit {
+  apple(1),
+  banana(2);
+
+  final int value;
+  const Fruit(this.value);
+
+  static Fruit fromValue(int value) => switch (value) {
+    1 => apple,
+    2 => banana,
+    _ => throw ArgumentError('Unknown value for Fruit: $value'),
+  };
+}
+
+final class Number extends ffi.Union {
+  @ffi.Int()
+  external int i;
+
+  @ffi.Float()
+  external double f;
+}
+
+final class Pair extends ffi.Struct {
+  @ffi.Int()
+  external int a;
+
+  @ffi.Int()
+  external int b;
+
+  static ffi.Pointer<Pair> $allocate(
+    ffi.Allocator $allocator, {
+    required int a,
+    required int b,
+  }) => $allocator<Pair>()
+    ..ref.a = a
+    ..ref.b = b;
+}
+
+enum ns$Flag {
+  off(0),
+  on(1);
+
+  final int value;
+  const ns$Flag(this.value);
+
+  static ns$Flag fromValue(int value) => switch (value) {
+    0 => off,
+    1 => on,
+    _ => throw ArgumentError('Unknown value for ns\$Flag: $value'),
+  };
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test.dart b/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test.dart
new file mode 100644
index 0000000000..dfcd1e4fc3
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test.dart
@@ -0,0 +1,51 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test/test.dart';
+
+import 'cpp_namespace_enum_test_bindings.dart';
+
+void main() {
+  group('CppNamespaceEnum', () {
+    test('enums in namespaces are generated with flattened names', () {
+      expect(GlobalBox$State, isNotNull);
+      expect(GlobalPalette$Shade, isNotNull);
+      expect(outer$Color, isNotNull);
+      expect(outer$inner$Color, isNotNull);
+      expect(outer$Palette$Tone, isNotNull);
+      expect(other$Color, isNotNull);
+    });
+
+    test('unscoped enum in a single namespace', () {
+      expect(outer$Color.red.value, 0);
+      expect(outer$Color.green.value, 1);
+      expect(outer$Color.blue.value, 2);
+    });
+
+    test('scoped enum (enum class) in a nested namespace', () {
+      expect(outer$inner$Color.cyan.value, 10);
+      expect(outer$inner$Color.magenta.value, 20);
+    });
+
+    test('scoped enum nested in a class inside a namespace', () {
+      expect(outer$Palette$Tone.light.value, 1);
+      expect(outer$Palette$Tone.dark.value, 2);
+    });
+
+    test('scoped enum nested in a class at global scope', () {
+      expect(GlobalPalette$Shade.dim.value, 7);
+      expect(GlobalPalette$Shade.bright.value, 8);
+    });
+
+    test('scoped enum nested in a struct at global scope', () {
+      expect(GlobalBox$State.closed.value, 30);
+      expect(GlobalBox$State.open.value, 31);
+    });
+
+    test('leaf-name collision across namespaces is disambiguated', () {
+      expect(other$Color.black.value, 100);
+      expect(other$Color.white.value, 200);
+    });
+  });
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test.h b/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test.h
new file mode 100644
index 0000000000..8c44858faa
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+namespace outer {
+// Unscoped enum in a single namespace.
+enum Color { red, green, blue };
+
+namespace inner {
+// Scoped enum (`enum class`) in a nested namespace. Shares the leaf name
+// `Color` with `outer::Color` and `other::Color`.
+enum class Color { cyan = 10, magenta = 20 };
+}  // namespace inner
+
+class Palette {
+ public:
+  // Scoped enum nested inside a class that is itself in a namespace.
+  enum class Tone { light = 1, dark = 2 };
+};
+}  // namespace outer
+
+namespace other {
+// Another `Color`, in a different namespace, to exercise leaf-name collisions.
+enum Color { black = 100, white = 200 };
+}  // namespace other
+
+class GlobalPalette {
+ public:
+  // Scoped enum nested inside a class at global scope.
+  enum class Shade { dim = 7, bright = 8 };
+};
+
+struct GlobalBox {
+  // Scoped enum nested inside a struct at global scope.
+  enum class State { closed = 30, open = 31 };
+};
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test_bindings.dart b/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test_bindings.dart
new file mode 100644
index 0000000000..872b64e22f
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_namespace_enum_test_bindings.dart
@@ -0,0 +1,91 @@
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `package:ffigen`.
+// ignore_for_file: type=lint, unused_import, unused_element, deprecated_member_use_from_same_package
+import 'dart:ffi' as ffi;
+
+enum GlobalBox$State {
+  closed(30),
+  open(31);
+
+  final int value;
+  const GlobalBox$State(this.value);
+
+  static GlobalBox$State fromValue(int value) => switch (value) {
+    30 => closed,
+    31 => open,
+    _ => throw ArgumentError('Unknown value for GlobalBox\$State: $value'),
+  };
+}
+
+enum GlobalPalette$Shade {
+  dim(7),
+  bright(8);
+
+  final int value;
+  const GlobalPalette$Shade(this.value);
+
+  static GlobalPalette$Shade fromValue(int value) => switch (value) {
+    7 => dim,
+    8 => bright,
+    _ => throw ArgumentError('Unknown value for GlobalPalette\$Shade: $value'),
+  };
+}
+
+enum other$Color {
+  black(100),
+  white(200);
+
+  final int value;
+  const other$Color(this.value);
+
+  static other$Color fromValue(int value) => switch (value) {
+    100 => black,
+    200 => white,
+    _ => throw ArgumentError('Unknown value for other\$Color: $value'),
+  };
+}
+
+enum outer$Color {
+  red(0),
+  green(1),
+  blue(2);
+
+  final int value;
+  const outer$Color(this.value);
+
+  static outer$Color fromValue(int value) => switch (value) {
+    0 => red,
+    1 => green,
+    2 => blue,
+    _ => throw ArgumentError('Unknown value for outer\$Color: $value'),
+  };
+}
+
+enum outer$Palette$Tone {
+  light(1),
+  dark(2);
+
+  final int value;
+  const outer$Palette$Tone(this.value);
+
+  static outer$Palette$Tone fromValue(int value) => switch (value) {
+    1 => light,
+    2 => dark,
+    _ => throw ArgumentError('Unknown value for outer\$Palette\$Tone: $value'),
+  };
+}
+
+enum outer$inner$Color {
+  cyan(10),
+  magenta(20);
+
+  final int value;
+  const outer$inner$Color(this.value);
+
+  static outer$inner$Color fromValue(int value) => switch (value) {
+    10 => cyan,
+    20 => magenta,
+    _ => throw ArgumentError('Unknown value for outer\$inner\$Color: $value'),
+  };
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test.dart b/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test.dart
new file mode 100644
index 0000000000..89c21b61dc
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test.dart
@@ -0,0 +1,72 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:ffi' as ffi;
+
+import 'package:test/test.dart';
+
+import 'cpp_scoped_struct_test_bindings.dart';
+
+void main() {
+  group('CppScopedStruct', () {
+    test('structs in scopes are generated with flattened names', () {
+      expect(GlobalBox, isNotNull);
+      expect(GlobalBox$Lid, isNotNull);
+      expect(outer$Point, isNotNull);
+      expect(outer$inner$Point, isNotNull);
+      expect(outer$Palette$Entry, isNotNull);
+      expect(other$Point, isNotNull);
+      expect(other$Value, isNotNull);
+    });
+
+    test('struct in a single namespace', () {
+      expect(ffi.sizeOf<outer$Point>(), 8);
+      final point = ffi.Struct.create<outer$Point>();
+      point.x = 1;
+      point.y = 2;
+      expect(point.x, 1);
+      expect(point.y, 2);
+    });
+
+    test('struct in a nested namespace', () {
+      expect(ffi.sizeOf<outer$inner$Point>(), 8);
+      final point = ffi.Struct.create<outer$inner$Point>();
+      point.x = 1.5;
+      point.y = 2.5;
+      expect(point.x, 1.5);
+      expect(point.y, 2.5);
+    });
+
+    test('struct nested in a class inside a namespace', () {
+      expect(ffi.sizeOf<outer$Palette$Entry>(), 4);
+      final entry = ffi.Struct.create<outer$Palette$Entry>();
+      entry.tone = 42;
+      expect(entry.tone, 42);
+    });
+
+    test('struct nested in a struct at global scope', () {
+      expect(ffi.sizeOf<GlobalBox$Lid>(), 4);
+      expect(ffi.sizeOf<GlobalBox>(), 8);
+      final box = ffi.Struct.create<GlobalBox>();
+      box.lid.hinge = 3;
+      box.size = 4;
+      expect(box.lid.hinge, 3);
+      expect(box.size, 4);
+    });
+
+    test('leaf-name collision across namespaces is disambiguated', () {
+      expect(ffi.sizeOf<other$Point>(), 8);
+      final point = ffi.Struct.create<other$Point>();
+      point.x = 3.25;
+      expect(point.x, 3.25);
+    });
+
+    test('union in a namespace', () {
+      expect(ffi.sizeOf<other$Value>(), 4);
+      final value = ffi.Union.create<other$Value>();
+      value.i = 7;
+      expect(value.i, 7);
+    });
+  });
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test.h b/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test.h
new file mode 100644
index 0000000000..0a1aaa3268
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2026, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+namespace outer {
+// Struct in a single namespace.
+struct Point {
+  int x;
+  int y;
+};
+
+namespace inner {
+// Struct in a nested namespace. Shares the leaf name `Point` with
+// `outer::Point` and `other::Point`.
+struct Point {
+  float x;
+  float y;
+};
+}  // namespace inner
+
+class Palette {
+ public:
+  // Struct nested inside a class that is itself in a namespace.
+  struct Entry {
+    int tone;
+  };
+};
+}  // namespace outer
+
+namespace other {
+// Another `Point`, in a different namespace, to exercise leaf-name collisions.
+struct Point {
+  double x;
+};
+
+// Union in a namespace.
+union Value {
+  int i;
+  float f;
+};
+}  // namespace other
+
+struct GlobalBox {
+  // Struct nested inside a struct at global scope, also used as a member of
+  // the enclosing struct.
+  struct Lid {
+    int hinge;
+  };
+  Lid lid;
+  int size;
+};
diff --git a/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test_bindings.dart b/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test_bindings.dart
new file mode 100644
index 0000000000..97a57c376e
--- /dev/null
+++ b/pkgs/ffigen/test/native_cpp_test/cpp_scoped_struct_test_bindings.dart
@@ -0,0 +1,82 @@
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `package:ffigen`.
+// ignore_for_file: type=lint, unused_import, unused_element, deprecated_member_use_from_same_package
+import 'dart:ffi' as ffi;
+
+final class GlobalBox extends ffi.Struct {
+  external GlobalBox$Lid lid;
+
+  @ffi.Int()
+  external int size;
+}
+
+final class GlobalBox$Lid extends ffi.Struct {
+  @ffi.Int()
+  external int hinge;
+
+  static ffi.Pointer<GlobalBox$Lid> $allocate(
+    ffi.Allocator $allocator, {
+    required int hinge,
+  }) => $allocator<GlobalBox$Lid>()..ref.hinge = hinge;
+}
+
+final class other$Point extends ffi.Struct {
+  @ffi.Double()
+  external double x;
+
+  static ffi.Pointer<other$Point> $allocate(
+    ffi.Allocator $allocator, {
+    required double x,
+  }) => $allocator<other$Point>()..ref.x = x;
+}
+
+final class other$Value extends ffi.Union {
+  @ffi.Int()
+  external int i;
+
+  @ffi.Float()
+  external double f;
+}
+
+final class outer$Palette$Entry extends ffi.Struct {
+  @ffi.Int()
+  external int tone;
+
+  static ffi.Pointer<outer$Palette$Entry> $allocate(
+    ffi.Allocator $allocator, {
+    required int tone,
+  }) => $allocator<outer$Palette$Entry>()..ref.tone = tone;
+}
+
+final class outer$Point extends ffi.Struct {
+  @ffi.Int()
+  external int x;
+
+  @ffi.Int()
+  external int y;
+
+  static ffi.Pointer<outer$Point> $allocate(
+    ffi.Allocator $allocator, {
+    required int x,
+    required int y,
+  }) => $allocator<outer$Point>()
+    ..ref.x = x
+    ..ref.y = y;
+}
+
+final class outer$inner$Point extends ffi.Struct {
+  @ffi.Float()
+  external double x;
+
+  @ffi.Float()
+  external double y;
+
+  static ffi.Pointer<outer$inner$Point> $allocate(
+    ffi.Allocator $allocator, {
+    required double x,
+    required double y,
+  }) => $allocator<outer$inner$Point>()
+    ..ref.x = x
+    ..ref.y = y;
+}
diff --git a/pkgs/ffigen/test/native_cpp_test/verify_bindings_test.dart b/pkgs/ffigen/test/native_cpp_test/verify_bindings_test.dart
index 09c0d68c3b..2561ab024e 100644
--- a/pkgs/ffigen/test/native_cpp_test/verify_bindings_test.dart
+++ b/pkgs/ffigen/test/native_cpp_test/verify_bindings_test.dart
@@ -48,6 +48,80 @@ void main() {
           classes: CppClasses.includeSet({'Animal', 'FinalizerTestSubject'}),
         ),
       ),
+      'cpp_constexpr': FfiGenerator(
+        output: Output(dartFile: Uri.file('cpp_constexpr_test_bindings.dart')),
+        headers: Headers(
+          entryPoints: [
+            Uri.file(path.join(testDir.path, 'cpp_constexpr_test.h')),
+          ],
+          compilerOptions: ['-x', 'c++'],
+        ),
+        globals: Globals.includeSet({
+          'topInt',
+          'topDouble',
+          'topStr',
+          'topDerived',
+          'ns::nsInt',
+          'ns::inner::nsInt',
+          'Box::memberInt',
+          'Box::memberDouble',
+          'Widget::classInt',
+          'scoped::Gadget::gadgetInt',
+        }),
+      ),
+      'cpp_extern_c': FfiGenerator(
+        output: Output(dartFile: Uri.file('cpp_extern_c_test_bindings.dart')),
+        headers: Headers(
+          entryPoints: [
+            Uri.file(path.join(testDir.path, 'cpp_extern_c_test.h')),
+          ],
+          compilerOptions: ['-x', 'c++'],
+        ),
+        functions: Functions.includeSet({'add', 'deep', 'reset', 'outside'}),
+        structs: Structs.includeSet({'Pair'}),
+        unions: Unions.includeSet({'Number'}),
+        enums: Enums.includeSet({'Fruit', 'ns::Flag'}),
+        globals: Globals.includeSet({'counter'}),
+      ),
+      'cpp_namespace_enum': FfiGenerator(
+        output: Output(
+          dartFile: Uri.file('cpp_namespace_enum_test_bindings.dart'),
+        ),
+        headers: Headers(
+          entryPoints: [
+            Uri.file(path.join(testDir.path, 'cpp_namespace_enum_test.h')),
+          ],
+          compilerOptions: ['-x', 'c++'],
+        ),
+        enums: Enums.includeSet({
+          'GlobalBox::State',
+          'GlobalPalette::Shade',
+          'outer::Color',
+          'outer::inner::Color',
+          'outer::Palette::Tone',
+          'other::Color',
+        }),
+      ),
+      'cpp_scoped_struct': FfiGenerator(
+        output: Output(
+          dartFile: Uri.file('cpp_scoped_struct_test_bindings.dart'),
+        ),
+        headers: Headers(
+          entryPoints: [
+            Uri.file(path.join(testDir.path, 'cpp_scoped_struct_test.h')),
+          ],
+          compilerOptions: ['-x', 'c++'],
+        ),
+        structs: Structs.includeSet({
+          'GlobalBox',
+          'GlobalBox::Lid',
+          'outer::Point',
+          'outer::inner::Point',
+          'outer::Palette::Entry',
+          'other::Point',
+        }),
+        unions: Unions.includeSet({'other::Value'}),
+      ),
     };
 
     for (final testFile in testFiles) {