XFail TestLambdas.py on Windows after fixing some of the problems

[amccarth]

Summary

1. Fixed semicolon placement in the lambda in the test itself.

2. Fixed lldbinline tests in general so that we don't attempt tests on platforms that don't use the given type of debug info. (For example, no DWO tests on Windows.) This fixes one of the two failures on Windows. (TestLambdas.py was the only inline test that wasn't XFailed or skipped on Windows.)

3. Set the error string in IRInterpreter::CanInterpret so that the caller doesn't print (null) instead of an explanation. I don't entirely understand the error, so feel free to suggest a better wording.

4. XFailed the test on Windows. The interpreter won't evaluate the lambda because the module has multiple function bodies. I don't exactly understand why that's a problem for the interpreter nor why the problem arises only on Windows.

[amccarth]

Zach is hoping to enable tests on our Windows build bot this week, so I'd like to land this in the next day or two if possible. If not, I can just xfail this test on Windows and postpone the other fixes until there's more time for a review.

Thanks.

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/lambdas/TestLambdas.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals(), [])
+lldbinline.MakeInlineTest(__file__, globals(), [lldbinline.expectedFailureAll(oslist=["windows"])])

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/lambdas/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 
 int main (int argc, char const *argv[])
 {
-    printf("Stop here\n");     //% self.runCmd("expression auto $add = [](int a, int b) { return a + b };")
-                               //% self.expect("expression $add(2,3)", substrs = ['= 5'])
-    return 0; 
+    printf("Stop here\n"); //% self.runCmd("expression auto $add = [](int a, int b) { return a + b; }")
+    return 0;
 }

lldb/trunk/packages/Python/lldbsuite/test/lldbinline.py

 def ApplyDecoratorsToFunction(func, decorators):
     tmp = func
     if type(decorators) == list:
         for decorator in decorators:
             tmp = decorator(tmp)
     elif hasattr(decorators, '__call__'):
         tmp = decorators(tmp)
     return tmp
-    
 
 def MakeInlineTest(__file, __globals, decorators=None):
     # Adjust the filename if it ends in .pyc.  We want filenames to
     # reflect the source python file, not the compiled variant.
     if __file is not None and __file.endswith(".pyc"):
         # Strip the trailing "c"
         __file = __file[0:-1]
 
     # Derive the test name from the current file name
     file_basename = os.path.basename(__file)
     InlineTest.mydir = TestBase.compute_mydir(__file)
 
     test_name, _ = os.path.splitext(file_basename)
-    # Build the test case 
+    # Build the test case
     test = type(test_name, (InlineTest,), {'using_dsym': None})
     test.name = test_name
 
+    target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+    if test_categories.is_supported_on_platform("dsym", target_platform):
         test.test_with_dsym = ApplyDecoratorsToFunction(test._InlineTest__test_with_dsym, decorators)
+    if test_categories.is_supported_on_platform("dwarf", target_platform):
         test.test_with_dwarf = ApplyDecoratorsToFunction(test._InlineTest__test_with_dwarf, decorators)
+    if test_categories.is_supported_on_platform("dwo", target_platform):
         test.test_with_dwo = ApplyDecoratorsToFunction(test._InlineTest__test_with_dwo, decorators)
 
     # Add the test case to the globals, and hide InlineTest
     __globals.update({test_name : test})
 
     # Keep track of the original test filename so we report it
     # correctly in test results.
     test.test_filename = __file
     return test
 

lldb/trunk/source/Expression/IRInterpreter.cpp

 //static const char *interpreter_initialization_error = "Interpreter couldn't be initialized";
 static const char *interpreter_internal_error       = "Interpreter encountered an internal error";
 static const char *bad_value_error                  = "Interpreter couldn't resolve a value during execution";
 static const char *memory_allocation_error          = "Interpreter couldn't allocate memory";
 static const char *memory_write_error               = "Interpreter couldn't write to memory";
 static const char *memory_read_error                = "Interpreter couldn't read from memory";
 static const char *infinite_loop_error              = "Interpreter ran for too many cycles";
 //static const char *bad_result_error                 = "Result of expression is in bad memory";
+static const char *too_many_functions_error = "Interpreter doesn't handle modules with multiple function bodies.";
 
 static bool
 CanResolveConstant (llvm::Constant *constant)
 {
     switch (constant->getValueID())
     {
     default:
         return false;
case Value::ConstantExprVal:
                 case Instruction::BitCast:
                     return CanResolveConstant(constant_expr->getOperand(0));
                 case Instruction::GetElementPtr:
                 {
                     ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin();
                     Constant *base = dyn_cast<Constant>(*op_cursor);
                     if (!base)
                         return false;
-                    
                     return CanResolveConstant(base);
                 }
             }
         } else {
             return false;
         }
     case Value::ConstantPointerNullVal:
         return true;
IRInterpreter::CanInterpret (llvm::Module &module,
 
     for (Module::iterator fi = module.begin(), fe = module.end();
          fi != fe;
          ++fi)
     {
         if (fi->begin() != fi->end())
         {
             if (saw_function_with_body)
+            {
+                if (log)
+                    log->Printf("More than one function in the module has a body");
+                error.SetErrorToGenericError();
+                error.SetErrorString(too_many_functions_error);
                 return false;
+            }
             saw_function_with_body = true;
         }
     }
 
     for (Function::iterator bbi = function.begin(), bbe = function.end();
          bbi != bbe;
          ++bbi)
     {
for (Function::iterator bbi = function.begin(), bbe = function.end();
                 case Type::VectorTyID:
                     {
                         if (log)
                             log->Printf("Unsupported operand type: %s", PrintType(operand_type).c_str());
                         error.SetErrorString(unsupported_operand_error);
                         return false;
                     }
                 }
-                
                 if (Constant *constant = llvm::dyn_cast<Constant>(operand))
                 {
                     if (!CanResolveConstant(constant))
                     {
                         if (log)
                             log->Printf("Unsupported constant: %s", PrintValue(constant).c_str());
                         error.SetErrorString(unsupported_operand_error);
                         return false;
                     }
                 }
             }
         }
 
     }
 
-    return true;}
+    return true;
+}
 
 bool
 IRInterpreter::Interpret (llvm::Module &module,
                           llvm::Function &function,
                           llvm::ArrayRef<lldb::addr_t> args,
                           lldb_private::IRExecutionUnit &execution_unit,
                           lldb_private::Error &error,
                           lldb::addr_t stack_frame_bottom,