diff --git a/pkgs/ffigen/lib/src/code_generator/constant.dart b/pkgs/ffigen/lib/src/code_generator/constant.dart
index 368ebb0b72..e74ab4a87a 100644
--- a/pkgs/ffigen/lib/src/code_generator/constant.dart
+++ b/pkgs/ffigen/lib/src/code_generator/constant.dart
@@ -11,7 +11,7 @@ import 'scope.dart';
 import 'utils.dart';
 import 'writer.dart';
 
-/// A simple Constant.
+/// Base class for constants.
 ///
 /// Expands to -
 /// ```dart
@@ -22,7 +22,7 @@ import 'writer.dart';
 /// ```dart
 /// const int name = 10;
 /// ```
-class Constant extends NoLookUpBinding {
+abstract class Constant extends NoLookUpBinding {
   /// The rawType is pasted as it is. E.g 'int', 'String', 'double'
   final String rawType;
 
@@ -62,12 +62,6 @@ class Constant extends NoLookUpBinding {
       string: s.toString(),
     );
   }
-
-  @override
-  public_ast.AstNode? toPublicAstNode() => public_ast.Constant(this);
-
-  @override
-  void visit(Visitation visitation) => visitation.visitConstant(this);
 }
 
 /// A [Constant] defined by an unnamed enum.
diff --git a/pkgs/ffigen/lib/src/code_generator/global.dart b/pkgs/ffigen/lib/src/code_generator/global.dart
index 8c4a59b706..aceda8d69b 100644
--- a/pkgs/ffigen/lib/src/code_generator/global.dart
+++ b/pkgs/ffigen/lib/src/code_generator/global.dart
@@ -29,12 +29,15 @@ class Global extends LookUpBinding with HasLocalScope {
   final Type type;
   final bool exposeSymbolAddress;
   final bool constant;
+  final ConstantValue? constantValue;
 
   @override
   final bool loadFromNativeAsset;
 
   bool isIncluded = false;
 
+  bool get isConst => constantValue != null && !exposeSymbolAddress;
+
   Global({
     super.usr,
     super.originalName,
@@ -43,6 +46,7 @@ class Global extends LookUpBinding with HasLocalScope {
     super.dartDoc,
     this.exposeSymbolAddress = false,
     this.constant = false,
+    this.constantValue,
     this.loadFromNativeAsset = false,
   }) : super(symbol: Symbol(name, SymbolKind.field));
 
@@ -54,6 +58,16 @@ class Global extends LookUpBinding with HasLocalScope {
     final s = StringBuffer();
     final globalVarName = name;
     s.write(makeDartDoc(dartDoc));
+    if (isConst) {
+      s.write(
+        'const ${constantValue!.type} $globalVarName = '
+        '${constantValue!.value};\n\n',
+      );
+      return BindingString(
+        type: BindingStringType.global,
+        string: s.toString(),
+      );
+    }
     final context = w.context;
     final dartType = type.getDartType(context);
     final ffiDartType = type.getFfiDartType(context);
@@ -173,6 +187,7 @@ class Global extends LookUpBinding with HasLocalScope {
   @override
   void visitChildren(Visitor visitor) {
     super.visitChildren(visitor);
+    if (isConst) return;
     visitor.visit(type);
     visitor.visit(ffiImport);
     if (loadFromNativeAsset && exposeSymbolAddress) {
@@ -183,3 +198,11 @@ class Global extends LookUpBinding with HasLocalScope {
   @override
   void visit(Visitation visitation) => visitation.visitGlobal(this);
 }
+
+/// A constant value for a [Global].
+class ConstantValue {
+  final String type;
+  final String value;
+
+  const ConstantValue({required this.type, required this.value});
+}
diff --git a/pkgs/ffigen/lib/src/code_generator/library.dart b/pkgs/ffigen/lib/src/code_generator/library.dart
index c37b2c2e88..c0df0abfba 100644
--- a/pkgs/ffigen/lib/src/code_generator/library.dart
+++ b/pkgs/ffigen/lib/src/code_generator/library.dart
@@ -55,6 +55,7 @@ class Library {
     // Seperate bindings which require lookup.
     final lookupBindings = <LookUpBinding>[];
     final nativeBindings = <LookUpBinding>[];
+    final noLookUpBindings = <Binding>[];
     String? nativeAssetId;
 
     final outputStyle = context.config.output.style;
@@ -62,15 +63,19 @@ class Library {
         ? outputStyle.assetId
         : null;
 
-    for (final binding in bindings.whereType<LookUpBinding>()) {
-      final loadFromNativeAsset = binding.loadFromNativeAsset;
+    for (final binding in bindings) {
+      // All LookUpBindings are look-up bindings, except const Globals.
+      if (binding is LookUpBinding && !(binding is Global && binding.isConst)) {
+        final loadFromNativeAsset = binding.loadFromNativeAsset;
 
-      // At the moment, all bindings share their native config.
-      if (loadFromNativeAsset) nativeAssetId = outputStyleAssetId;
+        // At the moment, all bindings share their native config.
+        if (loadFromNativeAsset) nativeAssetId = outputStyleAssetId;
 
-      (loadFromNativeAsset ? nativeBindings : lookupBindings).add(binding);
+        (loadFromNativeAsset ? nativeBindings : lookupBindings).add(binding);
+      } else {
+        noLookUpBindings.add(binding);
+      }
     }
-    final noLookUpBindings = bindings.whereType<NoLookUpBinding>().toList();
     final hasNoLookupNativeHelper = noLookUpBindings.any(
       (b) => b.hasNativeHelperFunctions,
     );
diff --git a/pkgs/ffigen/lib/src/code_generator/writer.dart b/pkgs/ffigen/lib/src/code_generator/writer.dart
index 46fb375e80..77b5ccd489 100644
--- a/pkgs/ffigen/lib/src/code_generator/writer.dart
+++ b/pkgs/ffigen/lib/src/code_generator/writer.dart
@@ -226,7 +226,7 @@ const _\$objcVersionCheck = $objcPrefix.ObjCVersionCheck(
 
     // Warn for macros.
     final hasMacroBindings = bindings.any(
-      (element) => element is Constant && element.usr.contains('@macro@'),
+      (element) => element is MacroConstant,
     );
     if (hasMacroBindings) {
       context.logger.info(
@@ -237,8 +237,7 @@ const _\$objcVersionCheck = $objcPrefix.ObjCVersionCheck(
 
     // Remove internal bindings and macros.
     bindings.removeWhere((element) {
-      return element.isInternal ||
-          (element is Constant && element.usr.contains('@macro@'));
+      return element.isInternal || (element is MacroConstant);
     });
 
     // Sort bindings alphabetically by USR.
diff --git a/pkgs/ffigen/lib/src/config_provider/public_ast.dart b/pkgs/ffigen/lib/src/config_provider/public_ast.dart
index 90f3ebd785..810a4e598a 100644
--- a/pkgs/ffigen/lib/src/config_provider/public_ast.dart
+++ b/pkgs/ffigen/lib/src/config_provider/public_ast.dart
@@ -196,32 +196,6 @@ class Global extends DeclNode {
   set isIncluded(bool value) => _global.isIncluded = value;
 }
 
-/// A C constant declaration.
-class Constant extends DeclNode {
-  final internal.Constant _constant;
-
-  Constant(this._constant);
-
-  @override
-  void accept(Visitor visitor) => visitor.visitConstant(this);
-
-  @override
-  String get usr => _constant.usr;
-
-  @override
-  String get originalName => _constant.originalName;
-
-  @override
-  String get name => _constant.symbol.oldName;
-
-  @override
-  set name(String value) => _constant.symbol.oldName = value;
-
-  /// Whether this Constant should be included in code generation.
-  bool get isIncluded => _constant.isIncluded;
-  set isIncluded(bool value) => _constant.isIncluded = value;
-}
-
 /// A C macro constant declaration.
 class MacroConstant extends DeclNode {
   final internal.MacroConstant _macro;
diff --git a/pkgs/ffigen/lib/src/config_provider/public_visitor.dart b/pkgs/ffigen/lib/src/config_provider/public_visitor.dart
index a242e41c15..66dfe84f31 100644
--- a/pkgs/ffigen/lib/src/config_provider/public_visitor.dart
+++ b/pkgs/ffigen/lib/src/config_provider/public_visitor.dart
@@ -73,7 +73,6 @@ abstract base class Visitor {
     void Function(Union) union,
     void Function(EnumClass) enumClass,
     void Function(Global) global,
-    void Function(Constant) constant,
     void Function(MacroConstant) macroConstant,
     void Function(Typealias) typealias,
     void Function(ObjCInterface) objCInterface,
@@ -99,7 +98,6 @@ abstract base class Visitor {
   void visitUnion(Union node) {}
   void visitEnum(EnumClass node) {}
   void visitGlobal(Global node) {}
-  void visitConstant(Constant node) {}
   void visitMacro(MacroConstant node) {}
   void visitTypealias(Typealias node) {}
   void visitObjCInterface(ObjCInterface node) {}
@@ -120,7 +118,6 @@ final class _CallbackVisitor extends Visitor {
   final void Function(Union) _union;
   final void Function(EnumClass) _enumClass;
   final void Function(Global) _global;
-  final void Function(Constant) _constant;
   final void Function(MacroConstant) _macroConstant;
   final void Function(Typealias) _typealias;
   final void Function(ObjCInterface) _objCInterface;
@@ -140,7 +137,6 @@ final class _CallbackVisitor extends Visitor {
     void Function(Union) union = _defaultVisit,
     void Function(EnumClass) enumClass = _defaultVisit,
     void Function(Global) global = _defaultVisit,
-    void Function(Constant) constant = _defaultVisit,
     void Function(MacroConstant) macroConstant = _defaultVisit,
     void Function(Typealias) typealias = _defaultVisit,
     void Function(ObjCInterface) objCInterface = _defaultVisit,
@@ -158,7 +154,6 @@ final class _CallbackVisitor extends Visitor {
        _union = union,
        _enumClass = enumClass,
        _global = global,
-       _constant = constant,
        _macroConstant = macroConstant,
        _typealias = typealias,
        _objCInterface = objCInterface,
@@ -190,9 +185,6 @@ final class _CallbackVisitor extends Visitor {
   @override
   void visitGlobal(Global node) => _global(node);
 
-  @override
-  void visitConstant(Constant node) => _constant(node);
-
   @override
   void visitMacro(MacroConstant node) => _macroConstant(node);
 
diff --git a/pkgs/ffigen/lib/src/config_provider/yaml_config.dart b/pkgs/ffigen/lib/src/config_provider/yaml_config.dart
index 9db5da5442..1909c1133a 100644
--- a/pkgs/ffigen/lib/src/config_provider/yaml_config.dart
+++ b/pkgs/ffigen/lib/src/config_provider/yaml_config.dart
@@ -1373,14 +1373,6 @@ final class YamlConfigAstVisitor extends public_ast.Visitor {
     }
   }
 
-  @override
-  void visitConstant(public_ast.Constant node) {
-    node.isIncluded = config.globals.shouldInclude(_decl(node));
-    if (config.globals.rename(_decl(node)) case final rename?) {
-      node.name = rename;
-    }
-  }
-
   @override
   void visitMacro(public_ast.MacroConstant node) {
     node.isIncluded = config.macroDecl.shouldInclude(_decl(node));
diff --git a/pkgs/ffigen/lib/src/context.dart b/pkgs/ffigen/lib/src/context.dart
index b67b899891..d2cddf04c6 100644
--- a/pkgs/ffigen/lib/src/context.dart
+++ b/pkgs/ffigen/lib/src/context.dart
@@ -22,7 +22,7 @@ class Context {
   final CursorIndex cursorIndex;
   final bindingsIndex = BindingsIndex();
   final savedMacros = <String, Macro>{};
-  final unnamedEnumConstants = <Constant>[];
+  final unnamedEnumConstants = <UnnamedEnumConstant>[];
   late final ObjCBuiltInFunctions objCBuiltInFunctions;
   bool hasSourceErrors = false;
   final reportedCommentRanges = <((String, int), (String, int))>{};
diff --git a/pkgs/ffigen/lib/src/header_parser/sub_parsers/unnamed_enumdecl_parser.dart b/pkgs/ffigen/lib/src/header_parser/sub_parsers/unnamed_enumdecl_parser.dart
index 2dec4a9965..003659b5f1 100644
--- a/pkgs/ffigen/lib/src/header_parser/sub_parsers/unnamed_enumdecl_parser.dart
+++ b/pkgs/ffigen/lib/src/header_parser/sub_parsers/unnamed_enumdecl_parser.dart
@@ -9,9 +9,12 @@ import '../utils.dart';
 import 'api_availability.dart';
 
 /// Saves unnamed enums.
-List<Constant> saveUnNamedEnum(Context context, clang_types.CXCursor cursor) {
+List<UnnamedEnumConstant> saveUnNamedEnum(
+  Context context,
+  clang_types.CXCursor cursor,
+) {
   final logger = context.logger;
-  final addedConstants = <Constant>[];
+  final addedConstants = <UnnamedEnumConstant>[];
   cursor.visitChildren((child) {
     try {
       logger.finest(
@@ -40,7 +43,7 @@ List<Constant> saveUnNamedEnum(Context context, clang_types.CXCursor cursor) {
 }
 
 /// Adds the parameter to func in functiondecl_parser.dart.
-Constant? _addUnNamedEnumConstant(
+UnnamedEnumConstant? _addUnNamedEnumConstant(
   Context context,
   clang_types.CXCursor cursor,
 ) {
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 2e6da6402f..ac2dd2364e 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
@@ -21,65 +21,34 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
   if (bindingsIndex.isSeenGlobalVar(usr)) {
     return bindingsIndex.getSeenGlobalVar(usr);
   }
-  if (bindingsIndex.isSeenVariableConstant(usr)) {
-    return bindingsIndex.getSeenVariableConstant(usr);
-  }
 
   final decl = Declaration(usr: usr, originalName: name);
   final cType = cursor.type();
 
-  // Try to evaluate as a constant first,
-  // unless the config asks for the variable's address.
-  if (cType.isConstQualified && !config.globals.includeSymbolAddress(decl)) {
+  ConstantValue? constantValue;
+  if (cType.isConstQualified) {
     final evalResult = clang.clang_Cursor_Evaluate(cursor);
     final evalKind = clang.clang_EvalResult_getKind(evalResult);
-    Constant? constant;
 
     switch (evalKind) {
       case clang_types.CXEvalResultKind.CXEval_Int:
         final value = clang.clang_EvalResult_getAsLongLong(evalResult);
-        constant = Constant(
-          usr: usr,
-          originalName: name,
-          name: name,
-          dartDoc: getCursorDocComment(context, cursor),
-          rawType: 'int',
-          rawValue: value.toString(),
-        );
+        constantValue = ConstantValue(type: 'int', value: value.toString());
         break;
       case clang_types.CXEvalResultKind.CXEval_Float:
         final value = clang.clang_EvalResult_getAsDouble(evalResult);
-        constant = Constant(
-          usr: usr,
-          originalName: name,
-          name: name,
-          dartDoc: getCursorDocComment(context, cursor),
-          rawType: 'double',
-          rawValue: writeDoubleAsString(value),
+        constantValue = ConstantValue(
+          type: 'double',
+          value: writeDoubleAsString(value),
         );
         break;
       case clang_types.CXEvalResultKind.CXEval_StrLiteral:
         final value = clang.clang_EvalResult_getAsStr(evalResult);
         final rawValue = getWrittenStringRepresentation(name, value, context);
-        constant = Constant(
-          usr: usr,
-          originalName: name,
-          name: name,
-          dartDoc: getCursorDocComment(context, cursor),
-          rawType: 'String',
-          rawValue: "'$rawValue'",
-        );
+        constantValue = ConstantValue(type: 'String', value: "'$rawValue'");
         break;
     }
     clang.clang_EvalResult_dispose(evalResult);
-
-    if (constant != null) {
-      logger.fine(
-        '++++ Adding Constant from Global: ${cursor.completeStringRepr()}',
-      );
-      bindingsIndex.addVariableConstantToSeen(usr, constant);
-      return constant;
-    }
   }
 
   logger.fine('++++ Adding Global: ${cursor.completeStringRepr()}');
@@ -107,6 +76,7 @@ Binding? parseVarDeclaration(Context context, clang_types.CXCursor cursor) {
     dartDoc: getCursorDocComment(context, cursor),
     exposeSymbolAddress: config.globals.includeSymbolAddress(decl),
     constant: cType.isConstQualified,
+    constantValue: constantValue,
     loadFromNativeAsset: nativeOutputStyle,
   );
   bindingsIndex.addGlobalVarToSeen(usr, global);
diff --git a/pkgs/ffigen/lib/src/header_parser/utils.dart b/pkgs/ffigen/lib/src/header_parser/utils.dart
index 9926440ad6..da2680d6cd 100644
--- a/pkgs/ffigen/lib/src/header_parser/utils.dart
+++ b/pkgs/ffigen/lib/src/header_parser/utils.dart
@@ -516,10 +516,9 @@ class Macro {
 class BindingsIndex {
   // Tracks if bindings are already seen, Map key is USR obtained from libclang.
   final Map<String, Func> _functions = {};
-  final Map<String, Constant> _unnamedEnumConstants = {};
+  final Map<String, UnnamedEnumConstant> _unnamedEnumConstants = {};
   final Map<String, String> _macros = {};
   final Map<String, Global> _globals = {};
-  final Map<String, Constant> _variableConstants = {};
   final Map<String, Typealias> _typealiases = {};
   final Map<String, EnumClass> _enums = {};
   final Map<String, Compound> _compounds = {};
@@ -535,18 +534,15 @@ class BindingsIndex {
   bool isSeenFunc(String usr) => _functions.containsKey(usr);
   void addFuncToSeen(String usr, Func func) => _functions[usr] = func;
   Func? getSeenFunc(String usr) => _functions[usr];
-  void addUnnamedEnumConstantToSeen(String usr, Constant enumConstant) =>
-      _unnamedEnumConstants[usr] = enumConstant;
-  Constant? getSeenUnnamedEnumConstant(String usr) =>
+  void addUnnamedEnumConstantToSeen(
+    String usr,
+    UnnamedEnumConstant enumConstant,
+  ) => _unnamedEnumConstants[usr] = enumConstant;
+  UnnamedEnumConstant? getSeenUnnamedEnumConstant(String usr) =>
       _unnamedEnumConstants[usr];
   bool isSeenGlobalVar(String usr) => _globals.containsKey(usr);
   void addGlobalVarToSeen(String usr, Global global) => _globals[usr] = global;
   Global? getSeenGlobalVar(String usr) => _globals[usr];
-  bool isSeenVariableConstant(String usr) =>
-      _variableConstants.containsKey(usr);
-  void addVariableConstantToSeen(String usr, Constant constant) =>
-      _variableConstants[usr] = constant;
-  Constant? getSeenVariableConstant(String usr) => _variableConstants[usr];
   bool isSeenTypealias(String usr) => _typealiases.containsKey(usr);
   void addTypealiasToSeen(String usr, Typealias t) => _typealiases[usr] = t;
   Typealias? getSeenTypealias(String usr) => _typealiases[usr];
diff --git a/pkgs/ffigen/lib/src/visitor/apply_config_filters.dart b/pkgs/ffigen/lib/src/visitor/apply_config_filters.dart
index 8b873d7aaf..f82db1b75c 100644
--- a/pkgs/ffigen/lib/src/visitor/apply_config_filters.dart
+++ b/pkgs/ffigen/lib/src/visitor/apply_config_filters.dart
@@ -100,13 +100,6 @@ class ApplyConfigFiltersVisitation extends Visitation {
   @override
   void visitGlobal(Global node) => _visitImpl(node, node.isIncluded);
 
-  @override
-  void visitConstant(Constant node) {
-    // MacroConstant and UnnamedEnumConstant have their own overrides, so this
-    // only applies to base Constants (e.g. from static const variables).
-    _visitImpl(node, node.isIncluded);
-  }
-
   @override
   void visitTypealias(Typealias node) {
     if (node.isAnonymous) return;
diff --git a/pkgs/ffigen/test/code_generator_tests/code_generator_test.dart b/pkgs/ffigen/test/code_generator_tests/code_generator_test.dart
index a2c5fbbb8e..8d1691bca3 100644
--- a/pkgs/ffigen/test/code_generator_tests/code_generator_test.dart
+++ b/pkgs/ffigen/test/code_generator_tests/code_generator_test.dart
@@ -342,6 +342,105 @@ void main() {
       _matchLib(library, 'constant');
     });
 
+    test('const global', () {
+      final context = makeContext();
+      final library = Library(
+        context: context,
+        header: '$licenseHeader\n',
+        bindings: transformBindings([
+          Global(
+            name: 'test1',
+            type: NativeType(SupportedNativeType.int32),
+            constant: true,
+            constantValue: const ConstantValue(type: 'int', value: '20'),
+          ),
+          Global(
+            name: 'test2',
+            type: NativeType(SupportedNativeType.double),
+            constant: true,
+            constantValue: const ConstantValue(type: 'double', value: '20.0'),
+          ),
+        ], context),
+      );
+      final output = library.generate();
+      expect(output, contains('const int test1 = 20;'));
+      expect(output, contains('const double test2 = 20.0;'));
+    });
+
+    withAndWithoutNative('const global with symbol address exposed', (
+      loadFromNativeAsset,
+    ) {
+      final context = makeContext(
+        output: Output(
+          dartFile: Uri.file('unused'),
+          style: loadFromNativeAsset
+              ? const NativeExternalBindings(assetId: 'test')
+              : const DynamicLibraryBindings(wrapperName: 'Bindings'),
+        ),
+      );
+      final g = Global(
+        loadFromNativeAsset: loadFromNativeAsset,
+        name: 'constWithAddress',
+        type: NativeType(SupportedNativeType.int32),
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '42'),
+        exposeSymbolAddress: true,
+      );
+      expect(g.isConst, isFalse);
+      final library = Library(
+        context: context,
+        bindings: transformBindings([g], context),
+      );
+      final output = library.generate();
+      if (loadFromNativeAsset) {
+        expect(output, contains('@ffi.Native<ffi.Int32>()'));
+        expect(output, contains('external final int constWithAddress;'));
+        expect(output, contains('const addresses = _SymbolAddresses();'));
+        expect(
+          output,
+          contains(
+            'ffi.Pointer<ffi.Int32> get constWithAddress => '
+            'ffi.Native.addressOf(self.constWithAddress);',
+          ),
+        );
+      } else {
+        expect(output, contains("lookup<ffi.Int32>('constWithAddress')"));
+        expect(output, contains('int get constWithAddress =>'));
+        expect(output, isNot(contains('set constWithAddress')));
+        expect(
+          output,
+          contains('late final addresses = _SymbolAddresses(this);'),
+        );
+        expect(
+          output,
+          contains(
+            'ffi.Pointer<ffi.Int32> get constWithAddress => '
+            '_library._constWithAddress;',
+          ),
+        );
+      }
+    });
+
+    test('Global.isConst', () {
+      final g1 = Global(
+        name: 'g1',
+        type: intType,
+        constantValue: const ConstantValue(type: 'int', value: '1'),
+      );
+      expect(g1.isConst, isTrue);
+
+      final g2 = Global(
+        name: 'g2',
+        type: intType,
+        constantValue: const ConstantValue(type: 'int', value: '1'),
+        exposeSymbolAddress: true,
+      );
+      expect(g2.isConst, isFalse);
+
+      final g3 = Global(name: 'g3', type: intType);
+      expect(g3.isConst, isFalse);
+    });
+
     test('enum_class', () {
       final context = makeContext();
       final library = Library(
diff --git a/pkgs/ffigen/test/config_tests/exclude_all_by_default_test.dart b/pkgs/ffigen/test/config_tests/exclude_all_by_default_test.dart
index 5ff2b8cd1e..11d8998f3c 100644
--- a/pkgs/ffigen/test/config_tests/exclude_all_by_default_test.dart
+++ b/pkgs/ffigen/test/config_tests/exclude_all_by_default_test.dart
@@ -27,9 +27,9 @@ ${strings.headers}:
       expect(library.getBinding('Struct'), isA<Struct>());
       expect(library.getBinding('Union'), isA<Union>());
       expect(library.getBinding('global'), isA<Global>());
-      expect(library.getBinding('MACRO'), isA<Constant>());
+      expect(library.getBinding('MACRO'), isA<MacroConstant>());
       expect(library.getBinding('Enum'), isA<EnumClass>());
-      expect(library.getBinding('unnamedEnum'), isA<Constant>());
+      expect(library.getBinding('unnamedEnum'), isA<UnnamedEnumConstant>());
     });
 
     test('exclude_all_by_default test flag true', () {
diff --git a/pkgs/ffigen/test/header_parser_tests/macros_test.dart b/pkgs/ffigen/test/header_parser_tests/macros_test.dart
index 4aab708d8b..296b38ffb0 100644
--- a/pkgs/ffigen/test/header_parser_tests/macros_test.dart
+++ b/pkgs/ffigen/test/header_parser_tests/macros_test.dart
@@ -148,36 +148,40 @@ Library expectedLibrary() {
   return Library(
     context: testContext(),
     bindings: [
-      Constant(name: 'TEST1', rawType: 'double', rawValue: '1.1'),
-      Constant(name: 'TEST2', rawType: 'int', rawValue: '10'),
-      Constant(name: 'TEST3', rawType: 'double', rawValue: '11.1'),
-      Constant(name: 'TEST4', rawType: 'String', rawValue: "'test'"),
-      Constant(name: 'TEST5', rawType: 'int', rawValue: '4'),
-      Constant(name: 'TEST6', rawType: 'int', rawValue: '1'),
-      Constant(name: 'TEST8', rawType: 'int', rawValue: '5'),
-      Constant(name: 'TEST9', rawType: 'String', rawValue: r"'\$dollar'"),
-      Constant(name: 'TEST10', rawType: 'String', rawValue: r"'test\'s'"),
-      Constant(name: 'TEST11', rawType: 'String', rawValue: r"'\x80'"),
-      Constant(
+      MacroConstant(name: 'TEST1', rawType: 'double', rawValue: '1.1'),
+      MacroConstant(name: 'TEST2', rawType: 'int', rawValue: '10'),
+      MacroConstant(name: 'TEST3', rawType: 'double', rawValue: '11.1'),
+      MacroConstant(name: 'TEST4', rawType: 'String', rawValue: "'test'"),
+      MacroConstant(name: 'TEST5', rawType: 'int', rawValue: '4'),
+      MacroConstant(name: 'TEST6', rawType: 'int', rawValue: '1'),
+      MacroConstant(name: 'TEST8', rawType: 'int', rawValue: '5'),
+      MacroConstant(name: 'TEST9', rawType: 'String', rawValue: r"'\$dollar'"),
+      MacroConstant(name: 'TEST10', rawType: 'String', rawValue: r"'test\'s'"),
+      MacroConstant(name: 'TEST11', rawType: 'String', rawValue: r"'\x80'"),
+      MacroConstant(
         name: 'TEST12',
         rawType: 'String',
         rawValue: r"'hello\n\t\r\v\b'",
       ),
-      Constant(name: 'TEST13', rawType: 'String', rawValue: r"'test\\'"),
-      Constant(
+      MacroConstant(name: 'TEST13', rawType: 'String', rawValue: r"'test\\'"),
+      MacroConstant(
         name: 'TEST14',
         rawType: 'double',
         rawValue: strings.doubleInfinity,
       ),
-      Constant(
+      MacroConstant(
         name: 'TEST15',
         rawType: 'double',
         rawValue: strings.doubleNegativeInfinity,
       ),
-      Constant(name: 'TEST16', rawType: 'double', rawValue: strings.doubleNaN),
-      Constant(name: 'TEST17', rawType: 'int', rawValue: '0'),
-      Constant(name: 'TEST18', rawType: 'int', rawValue: '4'),
-      Constant(name: 'TEST19', rawType: 'int', rawValue: '8'),
+      MacroConstant(
+        name: 'TEST16',
+        rawType: 'double',
+        rawValue: strings.doubleNaN,
+      ),
+      MacroConstant(name: 'TEST17', rawType: 'int', rawValue: '0'),
+      MacroConstant(name: 'TEST18', rawType: 'int', rawValue: '4'),
+      MacroConstant(name: 'TEST19', rawType: 'int', rawValue: '8'),
     ],
   )..forceFillNamesForTesting();
 }
diff --git a/pkgs/ffigen/test/header_parser_tests/static_const_test.dart b/pkgs/ffigen/test/header_parser_tests/static_const_test.dart
index a8fb0e4b86..a405e658af 100644
--- a/pkgs/ffigen/test/header_parser_tests/static_const_test.dart
+++ b/pkgs/ffigen/test/header_parser_tests/static_const_test.dart
@@ -191,60 +191,129 @@ Library expectedLibrary() {
   return Library(
     context: testContext(),
     bindings: [
-      Constant(name: 'TEST_INT', rawType: 'int', rawValue: '10'),
-      Constant(name: 'TEST_NEGATIVE_INT', rawType: 'int', rawValue: '-10'),
-      Constant(name: 'TEST_DOUBLE', rawType: 'double', rawValue: '3.14'),
-      Constant(
+      Global(
+        name: 'TEST_INT',
+        type: intType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '10'),
+      ),
+      Global(
+        name: 'TEST_NEGATIVE_INT',
+        type: intType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '-10'),
+      ),
+      Global(
+        name: 'TEST_DOUBLE',
+        type: doubleType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'double', value: '3.14'),
+      ),
+      Global(
         name: 'TEST_NEGATIVE_DOUBLE',
-        rawType: 'double',
-        rawValue: '-3.14',
-      ),
-      Constant(name: 'TEST_EXPRESSION', rawType: 'int', rawValue: '10'),
-      Constant(name: 'TEST_HEX', rawType: 'int', rawValue: '255'),
-      Constant(name: 'TEST_NEGATIVE_HEX', rawType: 'int', rawValue: '-255'),
-      Constant(name: 'TEST_STRING', rawType: 'String', rawValue: "'test'"),
-      Constant(
+        type: doubleType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'double', value: '-3.14'),
+      ),
+      Global(
+        name: 'TEST_EXPRESSION',
+        type: intType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '10'),
+      ),
+      Global(
+        name: 'TEST_HEX',
+        type: intType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '255'),
+      ),
+      Global(
+        name: 'TEST_NEGATIVE_HEX',
+        type: intType,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '-255'),
+      ),
+      Global(
+        name: 'TEST_STRING',
+        type: PointerType(charType),
+        constant: true,
+        constantValue: const ConstantValue(type: 'String', value: "'test'"),
+      ),
+      Global(
         name: 'TEST_STRING_SPECIAL',
-        rawType: 'String',
-        rawValue: r"'\$dollar'",
+        type: PointerType(charType),
+        constant: true,
+        constantValue: const ConstantValue(
+          type: 'String',
+          value: r"'\$dollar'",
+        ),
       ),
-      Constant(
+      Global(
         name: 'TEST_STRING_QUOTES',
-        rawType: 'String',
-        rawValue: r"'test\'s'",
+        type: PointerType(charType),
+        constant: true,
+        constantValue: const ConstantValue(type: 'String', value: r"'test\'s'"),
       ),
-      Constant(
+      Global(
         name: 'TEST_STRING_BACKSLASH',
-        rawType: 'String',
-        rawValue: r"'test\\'",
+        type: PointerType(charType),
+        constant: true,
+        constantValue: const ConstantValue(type: 'String', value: r"'test\\'"),
       ),
-      Constant(
+      Global(
         name: 'TEST_STRING_CONTROLS',
-        rawType: 'String',
-        rawValue: r"'hello\n\t\r\v\b'",
+        type: PointerType(charType),
+        constant: true,
+        constantValue: const ConstantValue(
+          type: 'String',
+          value: r"'hello\n\t\r\v\b'",
+        ),
       ),
-      Constant(
+      Global(
         name: 'TEST_INF',
-        rawType: 'double',
-        rawValue: strings.doubleInfinity,
+        type: doubleType,
+        constant: true,
+        constantValue: const ConstantValue(
+          type: 'double',
+          value: strings.doubleInfinity,
+        ),
       ),
-      Constant(
+      Global(
         name: 'TEST_NEGATIVE_INF',
-        rawType: 'double',
-        rawValue: strings.doubleNegativeInfinity,
+        type: doubleType,
+        constant: true,
+        constantValue: const ConstantValue(
+          type: 'double',
+          value: strings.doubleNegativeInfinity,
+        ),
       ),
-      Constant(
+      Global(
         name: 'TEST_NAN',
-        rawType: 'double',
-        rawValue: strings.doubleNaN,
+        type: doubleType,
+        constant: true,
+        constantValue: const ConstantValue(
+          type: 'double',
+          value: strings.doubleNaN,
+        ),
       ),
       myFlags,
       myBufferUsage,
-      Constant(name: 'MyBufferUsage_None', rawType: 'int', rawValue: '0'),
-      Constant(name: 'MyBufferUsage_MapRead', rawType: 'int', rawValue: '1'),
+      Global(
+        name: 'MyBufferUsage_None',
+        type: myBufferUsage,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '0'),
+      ),
+      Global(
+        name: 'MyBufferUsage_MapRead',
+        type: myBufferUsage,
+        constant: true,
+        constantValue: const ConstantValue(type: 'int', value: '1'),
+      ),
       Global(
         name: 'TEST_STRING_ARRAY',
         type: ConstantArray(11, charType, useArrayType: false),
+        constant: true,
       ),
       Global(name: 'test_global', type: intType),
     ],
diff --git a/pkgs/ffigen/test/header_parser_tests/unnamed_enums_test.dart b/pkgs/ffigen/test/header_parser_tests/unnamed_enums_test.dart
index 7cdba854b3..f4090fce7d 100644
--- a/pkgs/ffigen/test/header_parser_tests/unnamed_enums_test.dart
+++ b/pkgs/ffigen/test/header_parser_tests/unnamed_enums_test.dart
@@ -65,8 +65,8 @@ Library expectedLibrary() {
   return Library(
     context: testContext(),
     bindings: [
-      Constant(name: 'A', rawType: 'int', rawValue: '1'),
-      Constant(name: 'C', rawType: 'int', rawValue: '3'),
+      UnnamedEnumConstant(name: 'A', rawType: 'int', rawValue: '1'),
+      UnnamedEnumConstant(name: 'C', rawType: 'int', rawValue: '3'),
     ],
   )..forceFillNamesForTesting();
 }
diff --git a/pkgs/ffigen/test/large_integration_tests/large_objc_test.dart b/pkgs/ffigen/test/large_integration_tests/large_objc_test.dart
index 1389c5c2c3..4b40bd24c8 100644
--- a/pkgs/ffigen/test/large_integration_tests/large_objc_test.dart
+++ b/pkgs/ffigen/test/large_integration_tests/large_objc_test.dart
@@ -117,7 +117,6 @@ void main() {
           typealias: (node) =>
               node.isIncluded = stableRandomInclude('typedefs', node),
           macroConstant: (node) => node.isIncluded = false,
-          constant: (node) => node.isIncluded = false,
           objCInterface: (node) =>
               node.isIncluded = stableRandomInclude('objcInterfaces', node),
           objCProtocol: (node) => node.isIncluded = stableRandomInclude(
diff --git a/pkgs/ffigen/test/rename_tests/rename_test.dart b/pkgs/ffigen/test/rename_tests/rename_test.dart
index e23ec4bcd1..94afa36543 100644
--- a/pkgs/ffigen/test/rename_tests/rename_test.dart
+++ b/pkgs/ffigen/test/rename_tests/rename_test.dart
@@ -307,11 +307,23 @@ Library expectedLibrary() {
           EnumConstant(name: 'fullMatchSuccess', value: 1),
         ],
       ),
-      Constant(name: '${macroPrefix}Macro1', rawType: 'int', rawValue: '1'),
-      Constant(name: 'Macro2', rawType: 'int', rawValue: '2'),
-      Constant(name: 'Macro3', rawType: 'int', rawValue: '3'),
-      Constant(name: 'unnamed_underscore', rawType: 'int', rawValue: '0'),
-      Constant(name: 'unnamedFullMatchSuccess', rawType: 'int', rawValue: '1'),
+      MacroConstant(
+        name: '${macroPrefix}Macro1',
+        rawType: 'int',
+        rawValue: '1',
+      ),
+      MacroConstant(name: 'Macro2', rawType: 'int', rawValue: '2'),
+      MacroConstant(name: 'Macro3', rawType: 'int', rawValue: '3'),
+      UnnamedEnumConstant(
+        name: 'unnamed_underscore',
+        rawType: 'int',
+        rawValue: '0',
+      ),
+      UnnamedEnumConstant(
+        name: 'unnamedFullMatchSuccess',
+        rawType: 'int',
+        rawValue: '1',
+      ),
       struct5Alias,
     ],
   )..forceFillNamesForTesting();