Changeset 06ecda9

Timestamp:

Aug 3, 2024, 11:37:45 PM (5 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

bcb41f7

Parents:

1571e4d

Message:

define enum to value cost as implicit cost

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (1 diff)
• Cost.hpp (modified) (7 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -938 +938 @@
                         addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
                 } else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
-                        addEnumValueAsCandidate(enumInst, aggrExpr, Cost::unsafe);
+                        addEnumValueAsCandidate( enumInst, aggrExpr, Cost::implicit );
                 }
         }

src/ResolvExpr/Cost.hpp

@@ -31 +31 @@
                 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
                         // Little-endian => first value is low priority and last is high priority.
-                        unsigned char padding;                                  ///< unused
                         unsigned char referenceCost;                    ///< reference conversions
                         unsigned char specCost;                                 ///< Polymorphic type specializations (type assertions), negative cost
@@ -38 +37 @@
                         unsigned char safeCost;                                 ///< Safe (widening) conversions
                         unsigned char polyCost;                                 ///< Count of parameters and return values bound to some poly type
+                        unsigned char implicitCost;                             ///< Aggregate implicit cost
                         unsigned char unsafeCost;                               ///< Unsafe (narrowing) conversions
                 #else
@@ -46 +46 @@
         };
         static const unsigned char correctb = 0xff;             // byte correction for negative spec cost
-        static const uint64_t correctw = 0x00'00'00'00'00'ff'00'00; //' word correction for negative spec cost
+        static const uint64_t correctw = 0x00'00'00'00'00'00'ff'00; //' word correction for negative spec cost
   public:
         // Compiler adjusts constants for correct endian.
         enum : uint64_t {
-                zero      = 0x00'00'00'00'00'ff'00'00,
-                infinity  = 0xff'ff'ff'ff'ff'00'ff'ff,
-                unsafe    = 0x01'00'00'00'00'ff'00'00,
-                poly      = 0x00'01'00'00'00'ff'00'00,
-                safe      = 0x00'00'01'00'00'ff'00'00,
-                sign      = 0x00'00'00'01'00'ff'00'00,
-                var       = 0x00'00'00'00'01'ff'00'00,
-                spec      = 0x00'00'00'00'00'fe'00'00,
-                reference = 0x00'00'00'00'00'ff'01'00,
+                zero      = 0x00'00'00'00'00'00'ff'00,
+                infinity  = 0xff'ff'ff'ff'ff'ff'00'ff,
+                unsafe    = 0x01'00'00'00'00'00'ff'00,
+                implicit  = 0x00'01'00'00'01'00'ff'00,
+                poly      = 0x00'00'01'00'00'00'ff'00,
+                safe      = 0x00'00'00'01'00'00'ff'00,
+                sign      = 0x00'00'00'00'01'00'ff'00,
+                var       = 0x00'00'00'00'00'01'ff'00,
+                spec      = 0x00'00'00'00'00'00'fe'00,
+                reference = 0x00'00'00'00'00'00'ff'01,
         }; //'
 
         Cost( uint64_t all ) { Cost::all = all; }
-        Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int varCost, int specCost, int referenceCost ) {
+        Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int implicitCost, int varCost, int specCost, int referenceCost ) {
                 // Assume little-endian => first value is low priority and last is high priority.
                 v = {
                 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-                        (unsigned char)0,                                               // padding
                         (unsigned char)referenceCost,                   // low priority
                         (unsigned char)(specCost + correctb),   // correct for signedness
@@ -73 +73 @@
                         (unsigned char)safeCost,
                         (unsigned char)polyCost,
+                        (unsigned char)implicitCost,
                         (unsigned char)unsafeCost,                              // high priority
                 #else
@@ -81 +82 @@
 
         int get_unsafeCost() const { return v.unsafeCost; }
+        int get_implictCost() const { return v.implicitCost; }
         int get_polyCost() const { return v.polyCost; }
         int get_safeCost() const { return v.safeCost; }
@@ -112 +114 @@
         Cost incUnsafe( int inc = 1 ) {
                 if ( all != infinity ) { assert( v.unsafeCost + inc <= UCHAR_MAX ); v.unsafeCost += inc; }
+                return *this;
+        }
+
+        Cost incImplicit( int inc = 1 ) {
+                if ( all != infinity ) { assert( v.implicitCost + inc <= UCHAR_MAX ); v.implicitCost += inc; }
                 return *this;
         }
@@ -168 +175 @@
 
 inline std::ostream & operator<<( std::ostream & os, const Cost cost ) {
-        return os << "( " << cost.get_unsafeCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost()
+        return os << "( " << cost.get_unsafeCost() << ", " << cost.get_implictCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost()
                           << ", " << cost.get_signCost() << ", " << cost.get_varCost() << ", " << cost.get_specCost()
                           << ", " << cost.get_referenceCost() << " )";