From bf1abc232df44e0a1d8cc05d1783eb0326db5921 Mon Sep 17 00:00:00 2001
From: eisenwave <me@eisenwave.net>
Date: Sat, 31 Aug 2024 08:13:42 +0200
Subject: [PATCH] add constexpr-implicit-const diagnostic

---
 index.html       |  3 +++
 js/prose-decl.js | 63 +++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/index.html b/index.html
index 9d2453c..1321942 100644
--- a/index.html
+++ b/index.html
@@ -106,6 +106,9 @@ <h2>C Declarations &amp; printf/scanf &#10132; Prose</h2>
         <div id="d-empty-function-parameters" class="d-info" hidden>
             <span>Function with empty parameter list takes unspecified number of parameters</span>
         </div>
+        <div id="d-constexpr-implicit-const" class="d-info" hidden>
+            <span>Constexpr adds an implicit const in this case</span>
+        </div>
 
         <div id="d-format-syntax-error" class="d-error" hidden>
             <span>The given format string is invalid. This results in undefined behaviour.</span>
diff --git a/js/prose-decl.js b/js/prose-decl.js
index d51eb14..78cddcf 100644
--- a/js/prose-decl.js
+++ b/js/prose-decl.js
@@ -16,12 +16,25 @@ const SPECIFIER_CONFLICTS = [
     ['_Atomic', 'void']
 ];
 
+/**
+ * Type specifiers which explicitly denote a type.
+ * For example, `int` is considered to be explicit, whereas `short` is not in
+ * this set because it merely implies that the type is `int`.
+ * @type {Set<string>}
+ */
 const EXPLICIT_TYPE_SPECIFIERS = new Set([
     'void', 'char', 'int', 'bool',
     'float', 'double',
     'struct', 'class', 'union', 'enum',
     '_Atomic()', 'typedef-name']);
 
+/**
+ * Specifiers which result in an implicit `int` type, but do so idiomatically.
+ * For example, a `const x` declaration would implicitly be a `const int x`
+ * declaration in older C versions (and `const` is not in this set), but
+ * `short int x` still has this behavior and this is considered idiomatic.
+ * @type {Set<string>}
+ */
 const IDIOMATIC_IMPLICIT_INT_SPECIFIERS = new Set([
     'short', 'long', 'signed', 'unsigned'
 ]);
@@ -39,7 +52,8 @@ const INNER_SPECIFIER_TYPES = new Set([
 ]);
 
 const SPECIFIER_ORDERING = [
-    'typedef', 'extern', 'static', 'thread_local', 'auto', 'register', 'inline',
+    'typedef', 'extern', 'static', 'thread_local', 'auto', 'register',
+    'inline', 'constexpr',
     'const', 'volatile', 'restrict', '_Atomic',
     '_Atomic()', 'struct', 'class', 'enum',
     'void', 'bool', 'char', 'short', 'long', 'int',
@@ -137,7 +151,8 @@ export class Explainer {
 
     /**
      * Converts a declaration with specifiers already processed to prose.
-     * @param {Object} specifiersProse the prose so far
+     * @param {{histogram: Map<string, number>, atomic: string,
+     * outer: string, inner: string}} specifiersProse the prose so far
      * @param {Declarator} declarator the declarator
      * @param {DeclarationContext} kind the context
      * @returns {string} the prose paragraph
@@ -167,6 +182,12 @@ export class Explainer {
             }
         }
 
+        // TODO: add regression testing
+        if (histo.has('constexpr')
+            && !Explainer.isExplicitlyConst(declarator, histo.has('const'))) {
+            this.showDiagnostic('constexpr-implicit-const');
+        }
+
         const declaratorProse = this.declaratorToProse(declarator, kind);
         let result = declaratorProse.leadingIdentifier.length ?
             'Declare ' + declaratorProse.leadingIdentifier + ' ' : ' ';
@@ -178,11 +199,47 @@ export class Explainer {
         return result.trim();
     }
 
+    /**
+     * Returns whether the declarator is explicitly marked `const`.
+     * This happens in cases such as `const int`, `int * const`,
+     * `const int array[][]`, etc.
+     * @param {Declarator} declarator the declarator
+     * @param {boolean} outerConst `true` if an outer `const` is present
+     * @returns {boolean} `true` iff the declarator is explicitly const.
+     */
+    static isExplicitlyConst(declarator, outerConst) {
+        declarator = Explainer.withoutTrailing(declarator, d => d.typ === '[]');
+
+        if (declarator.length === 1 && declarator[0].typ === 'id') {
+            return outerConst;
+        }
+        const last = declarator[declarator.length - 1];
+        if (last.typ === '*') {
+            return last.qualifiers && last.qualifiers.includes('const');
+        }
+        return false;
+    }
+
+    /**
+     * Returns copy with all consecutive trailing elements that satisfy
+     * a given predicate removed.
+     * @param {Array} arr
+     * @param {any} predicate
+     * @returns {Array}
+     */
+    static withoutTrailing(arr, predicate) {
+        let end = arr.length;
+        while (end > 0 && predicate(arr[end - 1])) {
+            end--;
+        }
+        return arr.copyWithin(end, arr.length);
+    }
+
     /**
      * Converts a declaration specifier sequence to a prose object.
      * @param {DeclarationSpecifier[]} specifiers the specifiers
      * @param {DeclarationContext} kind the context
-     * @returns {{histogram: Map<string, number>, atomic: (string|string),
+     * @returns {{histogram: Map<string, number>, atomic: string,
      * outer: string, inner: string}}
      */
     specifiersToProse(specifiers, kind) {