Added support for indicating to the expression parser

that the result of an expression should be coerced to
a specific type.  Also made breakpoint conditions pass
in the bool type for this type.

The expression parser ignores this indication for now.

llvm-svn: 119779

7 files changed, 46 insertions, 9 deletions

diff --git a/lldb/include/lldb/Expression/ASTResultSynthesizer.h b/lldb/include/lldb/Expression/ASTResultSynthesizer.h
index d8d92599c3e..a1976135e2e 100644
--- a/lldb/include/lldb/Expression/ASTResultSynthesizer.h
+++ b/lldb/include/lldb/Expression/ASTResultSynthesizer.h
@@ -12,6 +12,7 @@
 
 #include "clang/Sema/SemaConsumer.h"
 #include "lldb/Core/ClangForward.h"
+#include "lldb/Symbol/TaggedASTType.h"
 
 namespace lldb_private {
 
@@ -39,8 +40,13 @@ public:
     ///     in order to produce LLVM IR, this SemaConsumer must allow them to
     ///     pass to the next step in the chain after processing.  Passthrough is
     ///     the next ASTConsumer, or NULL if none is required.
+    ///
+    /// @param[in] desired_type
+    ///     The type that the result should have.  May be initialized with a
+    ///     NULL type, in which case the type is inferred.
     //----------------------------------------------------------------------
-    ASTResultSynthesizer(clang::ASTConsumer *passthrough);
+    ASTResultSynthesizer(clang::ASTConsumer *passthrough,
+                         TypeFromUser desired_type);
     
     //----------------------------------------------------------------------
     /// Destructor
@@ -128,6 +134,7 @@ private:
     clang::ASTConsumer *m_passthrough;          ///< The ASTConsumer down the chain, for passthrough.  NULL if it's a SemaConsumer.
     clang::SemaConsumer *m_passthrough_sema;    ///< The SemaConsumer down the chain, for passthrough.  NULL if it's an ASTConsumer.
     clang::Sema *m_sema;                        ///< The Sema to use.
+    TypeFromUser m_desired_type;                ///< If non-NULL, the type to coerce the result to.
 };
 
 }
diff --git a/lldb/include/lldb/Expression/ClangUserExpression.h b/lldb/include/lldb/Expression/ClangUserExpression.h
index 6135a245ad9..6ff92c45149 100644
--- a/lldb/include/lldb/Expression/ClangUserExpression.h
+++ b/lldb/include/lldb/Expression/ClangUserExpression.h
@@ -25,6 +25,7 @@
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Expression/ClangExpression.h"
 #include "lldb/Expression/ClangExpressionVariable.h"
+#include "lldb/Symbol/TaggedASTType.h"
 
 #include "llvm/ExecutionEngine/JITMemoryManager.h"
 
@@ -73,11 +74,17 @@ public:
     ///     are needed for parsing (locations of functions, types of
     ///     variables, persistent variables, etc.)
     ///
+    /// @param[in] desired_type
+    ///     The type that the expression should be coerced to.  If NULL,
+    ///     inferred from the expression itself.
+    ///
     /// @return
     ///     True on success (no errors); false otherwise.
     //------------------------------------------------------------------
     bool
-    Parse (Stream &error_stream, ExecutionContext &exe_ctx);
+    Parse (Stream &error_stream, 
+           ExecutionContext &exe_ctx,
+           TypeFromUser desired_type);
     
     //------------------------------------------------------------------
     /// Execute the parsed expression
@@ -238,6 +245,7 @@ private:
     std::string                                 m_expr_text;            ///< The text of the expression, as typed by the user
     std::string                                 m_expr_prefix;          ///< The text of the translation-level definitions, as provided by the user
     std::string                                 m_transformed_text;     ///< The text of the expression, as send to the parser
+    TypeFromUser                                m_desired_type;         ///< The type to coerce the expression's result to.  If NULL, inferred from the expression.
     
     std::auto_ptr<ClangExpressionDeclMap>       m_expr_decl_map;        ///< The map to use when parsing and materializing the expression.
     std::auto_ptr<ClangExpressionVariableStore> m_local_variables;      ///< The local expression variables, if the expression is DWARF.
diff --git a/lldb/include/lldb/Symbol/ClangASTContext.h b/lldb/include/lldb/Symbol/ClangASTContext.h
index 3b1d1aa87e8..4ea32602e46 100644
--- a/lldb/include/lldb/Symbol/ClangASTContext.h
+++ b/lldb/include/lldb/Symbol/ClangASTContext.h
@@ -126,6 +126,9 @@ public:
     {
         return GetBuiltInType_void(getASTContext());
     }
+    
+    lldb::clang_type_t
+    GetBuiltInType_bool();
 
     lldb::clang_type_t
     GetBuiltInType_objc_id();
diff --git a/lldb/source/Breakpoint/BreakpointOptions.cpp b/lldb/source/Breakpoint/BreakpointOptions.cpp
index 713c2e90c50..975c8364053 100644
--- a/lldb/source/Breakpoint/BreakpointOptions.cpp
+++ b/lldb/source/Breakpoint/BreakpointOptions.cpp
@@ -18,6 +18,7 @@
 #include "lldb/Core/Value.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/ThreadPlanTestCondition.h"
 
@@ -193,8 +194,12 @@ BreakpointOptions::GetThreadPlanToTestCondition (ExecutionContext &exe_ctx,
         
         exe_ctx.process->SetDynamicCheckers(dynamic_checkers);
     }
+    
+    // Get the boolean type from the process's scratch AST context
+    ClangASTContext *ast_context = exe_ctx.target->GetScratchClangASTContext();
+    TypeFromUser bool_type(ast_context->GetBuiltInType_bool(), ast_context->getASTContext());
 
-    if (!m_condition_ap->Parse (error_stream, exe_ctx))
+    if (!m_condition_ap->Parse (error_stream, exe_ctx, bool_type))
     {
         // Errors mean we should stop.
         return NULL;
diff --git a/lldb/source/Expression/ASTResultSynthesizer.cpp b/lldb/source/Expression/ASTResultSynthesizer.cpp
index 707875631bb..bcabfe3badc 100644
--- a/lldb/source/Expression/ASTResultSynthesizer.cpp
+++ b/lldb/source/Expression/ASTResultSynthesizer.cpp
@@ -24,11 +24,13 @@ using namespace llvm;
 using namespace clang;
 using namespace lldb_private;
 
-ASTResultSynthesizer::ASTResultSynthesizer(ASTConsumer *passthrough) :
+ASTResultSynthesizer::ASTResultSynthesizer(ASTConsumer *passthrough,
+                                           TypeFromUser desired_type) :
     m_ast_context (NULL),
     m_passthrough (passthrough),
     m_passthrough_sema (NULL),
-    m_sema (NULL)
+    m_sema (NULL),
+    m_desired_type (desired_type)
 {
     if (!m_passthrough)
         return;
diff --git a/lldb/source/Expression/ClangUserExpression.cpp b/lldb/source/Expression/ClangUserExpression.cpp
index f3515289741..3e4827b9f0f 100644
--- a/lldb/source/Expression/ClangUserExpression.cpp
+++ b/lldb/source/Expression/ClangUserExpression.cpp
@@ -44,7 +44,8 @@ ClangUserExpression::ClangUserExpression (const char *expr,
     m_jit_addr(LLDB_INVALID_ADDRESS),
     m_cplusplus(false),
     m_objectivec(false),
-    m_needs_object_ptr(false)
+    m_needs_object_ptr(false),
+    m_desired_type(NULL, NULL)
 {
 }
 
@@ -55,7 +56,8 @@ ClangUserExpression::~ClangUserExpression ()
 clang::ASTConsumer *
 ClangUserExpression::ASTTransformer (clang::ASTConsumer *passthrough)
 {
-    return new ASTResultSynthesizer(passthrough);
+    return new ASTResultSynthesizer(passthrough,
+                                    m_desired_type);
 }
 
 void
@@ -115,7 +117,9 @@ ApplyUnicharHack(std::string &expr)
 }
 
 bool
-ClangUserExpression::Parse (Stream &error_stream, ExecutionContext &exe_ctx)
+ClangUserExpression::Parse (Stream &error_stream, 
+                            ExecutionContext &exe_ctx,
+                            TypeFromUser desired_type)
 {
     lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
     
@@ -194,6 +198,8 @@ ClangUserExpression::Parse (Stream &error_stream, ExecutionContext &exe_ctx)
     // Parse the expression
     //
     
+    m_desired_type = desired_type;
+    
     m_expr_decl_map.reset(new ClangExpressionDeclMap(&exe_ctx));
     
     ClangExpressionParser parser(target_triple.GetCString(), *this);
@@ -452,7 +458,7 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
     
     StreamString error_stream;
     
-    if (!user_expression.Parse (error_stream, exe_ctx))
+    if (!user_expression.Parse (error_stream, exe_ctx, TypeFromUser(NULL, NULL)))
     {
         if (error_stream.GetString().empty())
             error.SetErrorString ("expression failed to parse, unknown error");
diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp
index 1ab02b989f9..13302756339 100644
--- a/lldb/source/Symbol/ClangASTContext.cpp
+++ b/lldb/source/Symbol/ClangASTContext.cpp
@@ -671,6 +671,12 @@ ClangASTContext::GetBuiltInType_void(ASTContext *ast_context)
 }
 
 clang_type_t
+ClangASTContext::GetBuiltInType_bool()
+{
+    return getASTContext()->BoolTy.getAsOpaquePtr();
+}
+
+clang_type_t
 ClangASTContext::GetBuiltInType_objc_id()
 {
     return getASTContext()->ObjCBuiltinIdTy.getAsOpaquePtr();