Changeset c36298d for src/AST/Expr.hpp

Timestamp:

Jun 17, 2019, 11:01:04 AM (5 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b4d34fa

Parents:

6a1dfda

Message:

Fixed handling of "literals.cfa" string-detail test cases by simplifying constant analysis. Now a ConstantExpr? is a minial passthrough from parser to code generator, with special-case analysis only for integer values. Awareness of how to build a string-constant type is back in ExpressionNode?.cc; now, this knowlede is only needed there. AST conversion no longer specializes string-int-float constants; it just converts types and passes values through. Unused constant API features are removed, notably from-to-float and from-string.

File:

• src/AST/Expr.hpp (modified) (4 diffs)

src/AST/Expr.hpp

@@ -22 +22 @@
 #include <utility>        // for move
 #include <vector>
+#include <optional>
 
 #include "Fwd.hpp"        // for UniqueId
@@ -32 +33 @@
 
 class ConverterOldToNew;
+class ConverterNewToOld;
 
 namespace ast {
@@ -346 +348 @@
 };
 
-/// A compile-time constant
+/// A compile-time constant.
+/// Mostly carries C-source text from parse to code-gen, without interpretation.  E.g. strings keep their outer quotes and never have backslashes interpreted.
+/// Integer constants get special treatment, e.g. for verifying array operations, when an integer constant occurs as the length of an array.
 class ConstantExpr final : public Expr {
-        union Val {
-                unsigned long long ival;
-                double dval;
-
-                Val( unsigned long long i ) : ival( i ) {}
-                Val( double d ) : dval( d ) {}
-        } val;
-public:
+public:
+        // Representation of this constant, as it occurs in .cfa source and .cfa.cc result.
         std::string rep;
-        enum Kind { Integer, FloatingPoint, String } kind;
 
         ConstantExpr(
-                const CodeLocation & loc, const Type * ty, const std::string & r, unsigned long long v,
-                Kind k = Integer )
-        : Expr( loc, ty ), val( v ), rep( r ), kind( k ) {}
-        ConstantExpr( const CodeLocation & loc, const Type * ty, const std::string & r, double v )
-        : Expr( loc, ty ), val( v ), rep( r ), kind( FloatingPoint ) {}
-
-        /// Gets the value of this constant as an integer
+                const CodeLocation & loc, const Type * ty, const std::string & r, 
+                        std::optional<unsigned long long> i )
+        : Expr( loc, ty ), rep( r ), ival( i ) {}
+
+        /// Gets the integer value of this constant, if one is appropriate to its type.
+        /// Throws a SemanticError if the type is not appropriate for value-as-integer.
+        /// Suffers an assertion failure the type is appropriate but no integer value was supplied to the constructor.
         long long int intValue() const;
-        /// Gets the value of this constant as floating point
-        double floatValue() const;
 
         /// generates a boolean constant of the given bool
         static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
-        /// generates a char constant of the given char
-        static ConstantExpr * from_char( const CodeLocation & loc, char c );
         /// generates an integer constant of the given int
         static ConstantExpr * from_int( const CodeLocation & loc, int i );
         /// generates an integer constant of the given unsigned long int
         static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
-        /// generates a floating point constant of the given double
-        static ConstantExpr * from_double( const CodeLocation & loc, double d );
         /// generates a null pointer value for the given type. void * if omitted.
         static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
@@ -388 +379 @@
         ConstantExpr * clone() const override { return new ConstantExpr{ *this }; }
         MUTATE_FRIEND
+
+        std::optional<unsigned long long> ival;
+
+        // Intended only for legacy support of roundtripping the old AST.
+        // Captures the very-locally inferred type, before the resolver modifies the type of this ConstantExpression.
+        // In the old AST it's constExpr->constant.type
+        ptr<Type> underlyer;
+        friend class ::ConverterOldToNew;
+        friend class ::ConverterNewToOld;
 };