Changeset 4702a2c for src

Timestamp:

Nov 25, 2020, 3:14:30 AM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

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

Children:

0292aa4, 1389810

Parents:

e5c3811 (diff), bb87dd0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Expr.hpp (modified) (1 diff)
• InitTweak/FixInit.h (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/Resolver.h (modified) (2 diffs)

src/AST/Expr.hpp

@@ -299 +299 @@
 };
 
-/// Whether a cast existed in the program source or not
+/// Inidicates whether the cast is introduced by the CFA type system.
+/// GeneratedCast for casts that the resolver introduces to force a return type
+/// ExplicitCast for casts from user code
+/// ExplicitCast for casts from desugaring advanced CFA features into simpler CFA
+/// example
+///   int * p;     // declaration
+///   (float *) p; // use, with subject cast
+/// subject cast being GeneratedCast means we are considering an interpretation with a type mismatch
+/// subject cast being ExplicitCast means someone in charge wants it that way
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 

src/InitTweak/FixInit.h

@@ -21 +21 @@
 class Declaration;
 namespace ast {
-        class TranslationUnit;
+        struct TranslationUnit;
 }
 

src/Parser/ParseNode.h

@@ -37 +37 @@
 class Attribute;
 class Declaration;
-class DeclarationNode;
+struct DeclarationNode;
 class DeclarationWithType;
 class ExpressionNode;
 class Initializer;
-class StatementNode;
+struct StatementNode;
 
 //##############################################################################

src/ResolvExpr/CandidateFinder.cpp

@@ -1101 +1101 @@
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
-                                Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                symtab, cand->env );
+                                Cost thisCost = 
+                                        (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
+                            ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
+                            : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
+
                                 PRINT(
                                         std::cerr << "working on cast with result: " << toType << std::endl;
@@ -1591 +1594 @@
 
                                         // unification run for side-effects
-                                        unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
+                    (void) canUnify;
                                         Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                symtab, env );
+                                        PRINT(
+                                                Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
                                                         symtab, env );
-
+                                                std::cerr << "Considering initialization:";
+                                                std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
+                                                std::cerr << std::endl << "  TO: "   << toType             << std::endl;
+                                                std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                                std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                                std::cerr << std::endl << "  New cost " << thisCost;
+                                                std::cerr << std::endl;
+                                        )
                                         if ( thisCost != Cost::infinity ) {
                                                 // count one safe conversion for each value that is thrown away

src/ResolvExpr/Resolver.h

@@ -35 +35 @@
         class StmtExpr;
         class SymbolTable;
-        class TranslationUnit;
+        struct TranslationUnit;
         class Type;
         class TypeEnvironment;
@@ -63 +63 @@
         ast::ptr< ast::Expr > resolveInVoidContext(
                 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env );
-        /// Resolve `untyped` to the single expression whose candidate is the best match for the 
+        /// Resolve `untyped` to the single expression whose candidate is the best match for the
         /// given type.
         ast::ptr< ast::Expr > findSingleExpression(