[lldb][test] Replace use of p with expression (NFC)

[kastiglione]

Summary

In API tests, replace use of the p alias with the expression command.

To avoid conflating tests of the alias with tests of the expression command,
this patch canonicalizes to the use expression.

[aprantl]

I think it makes sense to have one test that tests the p command alias and its parameter handling and have all other tests be explicit about whether they test the expression evaluator or the command alias. As such, this is a good canonicalization.

lldb/test/API/python_api/file_handle/TestFileHandle.py

138

not your code, but does the /x serve any purpose here?

[kastiglione]

I will add explicit tests for p.

lldb/test/API/python_api/file_handle/TestFileHandle.py

138

a couple lines below they read in the output from this command, and compare hex 3735928559 to "deadbeef".

[kastiglione]

lldb/test/API/functionalities/multiple-slides/TestMultipleSlides.py

74

@aprantl I don't see why these /d are not needed though.

[aprantl]

lldb/test/API/functionalities/multiple-slides/TestMultipleSlides.py

74

Oh otherwise they'd be printed in hex. Makes sense.

[kastiglione]

Add a test for p; Replace few instances of print with expression too.

lldb/test/API/commands/expression/call-function/TestCallStdStringFunction.py

@expectedFailureAll(
         bugnumber="llvm.org/pr14437, fails with ICC 13.1")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     @skipIf(compiler="clang", compiler_version=['<', '9.0'])
     def test_with(self):
         """Test calling std::String member function."""
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
 
-        self.expect("print str",
+        self.expect("expression str",
                     substrs=['Hello world'])
 
         # Calling this function now succeeds, but we follow the typedef return type through to
         # const char *, and thus don't invoke the Summary formatter.
 
         # clang's libstdc++ on ios arm64 inlines std::string::c_str() always;
         # skip this part of the test.
         triple = self.dbg.GetSelectedPlatform().GetTriple()
         do_cstr_test = True
         if triple in ["arm64-apple-ios", "arm64e-apple-ios", "arm64-apple-tvos", "armv7k-apple-watchos", "arm64-apple-bridgeos", "arm64_32-apple-watchos"]:
             do_cstr_test = False
         if do_cstr_test:
-            self.expect("print str.c_str()",
+            self.expect("expression str.c_str()",
                         substrs=['Hello world'])

lldb/test/API/commands/expression/codegen-crash-typedefdecl-not-in_declcontext/main.cpp

struct B {
   NS::DW spd;
   int a = 0;
 };
 
 struct E {
   E(B &b) : b_ref(b) {}
   NS::DW f() { return {}; };
   void g() {
-    return; //%self.expect("p b_ref", substrs=['(B) $0 =', '(spd = NS::DW', 'a = 0)'])
+    return; //%self.expect("expression b_ref", substrs=['(B) $0 =', '(spd = NS::DW', 'a = 0)'])
   }
 
   B &b_ref;
 };
 
 int main() {
   B b;
   E e(b);
 
   e.g();
 
   return 0;
 }

lldb/test/API/commands/expression/persist_objc_pointeetype/TestPersistObjCPointeeType.py

def test_with(self):
 
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
-        self.expect("p *self", substrs=['_sc_name = nil',
-                                        '_sc_name2 = nil',
-                                        '_sc_name3 = nil',
-                                        '_sc_name4 = nil',
-                                        '_sc_name5 = nil',
-                                        '_sc_name6 = nil',
-                                        '_sc_name7 = nil',
-                                        '_sc_name8 = nil'])
+        self.expect(
+            "expression *self",
+            substrs=[
+                "_sc_name = nil",
+                "_sc_name2 = nil",
+                "_sc_name3 = nil",
+                "_sc_name4 = nil",
+                "_sc_name5 = nil",
+                "_sc_name6 = nil",
+                "_sc_name7 = nil",
+                "_sc_name8 = nil",
+            ],
+        )

lldb/test/API/commands/expression/rdar44436068/main.c

 int main(void)
 {
     __int128_t n = 1;
     n = n + n;
-    return n; //%self.expect("p n", substrs=['(__int128_t) $0 = 2'])
-              //%self.expect("p n + 6", substrs=['(__int128_t) $1 = 8'])
-              //%self.expect("p n + n", substrs=['(__int128_t) $2 = 4'])
+    return n; //%self.expect("expression n", substrs=['(__int128_t) $0 = 2'])
+              //%self.expect("expression n + 6", substrs=['(__int128_t) $1 = 8'])
+              //%self.expect("expression n + n", substrs=['(__int128_t) $2 = 4'])
 }

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/TestSVERegisters.py

def test_sve_registers_read_write(self):
         vg_reg_value = sve_registers.GetChildMemberWithName(
             "vg").GetValueAsUnsigned()
 
         z_reg_size = vg_reg_value * 8
 
         self.check_sve_regs_read(z_reg_size)
 
         # Evaluate simple expression and print function expr_eval_func address.
-        self.expect("p expr_eval_func", substrs=["= 0x"])
+        self.expect("expression expr_eval_func", substrs=["= 0x"])
 
         # Evaluate expression call function expr_eval_func.
         self.expect_expr("expr_eval_func()",
                          result_type="int", result_value="1")
 
         # We called a jitted function above which must not have changed SVE
         # vector length or register values.
         self.check_sve_regs_read(z_reg_size)
 
         self.check_sve_regs_read_after_write(z_reg_size)

lldb/test/API/commands/target/dump-pcm-info/TestDumpPCMInfo.py

def test(self):
 
         mod_cache = self.getBuildArtifact("private-module-cache")
         if os.path.isdir(mod_cache):
             shutil.rmtree(mod_cache)
 
         self.runCmd(f"settings set symbols.clang-modules-cache-path '{mod_cache}'")
 
         # Cause lldb to generate a Darwin-*.pcm
-        self.runCmd("p @import Darwin")
+        self.runCmd("expression @import Darwin")
 
         # root/<config-hash>/<module-name>-<modulemap-path-hash>.pcm
         pcm_paths = glob.glob(os.path.join(mod_cache, '*', 'Darwin-*.pcm'))
         self.assertEqual(len(pcm_paths), 1, "Expected one Darwin pcm")
         pcm_path = pcm_paths[0]
 
         self.expect(
             f"target modules dump pcm-info '{pcm_path}'",
             startstr=f"Information for module file '{pcm_path}'",
             substrs=["Module name: Darwin"])

lldb/test/API/functionalities/alias/Makefile

+C_SOURCES := main.c
+CFLAGS_EXTRAS := -std=c99
+
+include Makefile.rules

lldb/test/API/functionalities/alias/TestPAlias.py

+import lldb
+from lldbsuite.test.lldbtest import TestBase
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+    def test(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "return", lldb.SBFileSpec("main.c"))
+        self.expect("p -g", substrs=["$0 = -"])
+        self.expect("p -i0 -g", error=True)

lldb/test/API/functionalities/alias/main.c

+int main() {
+  int g = 41;
+  return 0;
+}

lldb/test/API/functionalities/backticks/TestBackticksWithoutATarget.py

 from lldbsuite.test import lldbutil
 
 
 class BackticksWithNoTargetTestCase(TestBase):
 
     @no_debug_info_test
     def test_backticks_no_target(self):
         """A simple test of backticks without a target."""
-        self.expect("print `1+2-3`",
+        self.expect("expression `1+2-3`",
                     substrs=[' = 0'])

lldb/test/API/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.py

def test_with_run_command(self):
 
         # Check that our order of priority works. Start by clearing categories
         self.runCmd("type category delete Category1")
 
         self.runCmd(
             "type summary add Shape -w BaseCategory --summary-string \"AShape\"")
         self.runCmd("type category enable BaseCategory")
 
-        self.expect("print (Shape*)&c1",
+        self.expect("expression (Shape*)&c1",
                     substrs=['AShape'])
-        self.expect("print (Shape*)&r1",
+        self.expect("expression (Shape*)&r1",
                     substrs=['AShape'])
-        self.expect("print (Shape*)c_ptr",
+        self.expect("expression (Shape*)c_ptr",
                     substrs=['AShape'])
-        self.expect("print (Shape*)r_ptr",
+        self.expect("expression (Shape*)r_ptr",
                     substrs=['AShape'])
 
         self.runCmd(
             "type summary add Circle -w CircleCategory --summary-string \"ACircle\"")
         self.runCmd(
             "type summary add Rectangle -w RectangleCategory --summary-string \"ARectangle\"")
         self.runCmd("type category enable CircleCategory")
 

lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py

def test_with_run_command(self):
         self.runCmd(
             "type summary add --summary-string \"arr = ${var%s}\" -x \"char\\[[0-9]+\\]\" -v")
 
         self.expect("frame variable strarr",
                     substrs=['arr = "Hello world!'])
 
         # check that rdar://problem/10011145 (Standard summary format for
         # char[] doesn't work as the result of "expr".) is solved
-        self.expect("p strarr",
+        self.expect("expression strarr",
                     substrs=['arr = "Hello world!'])
 
         self.expect("frame variable strptr",
                     substrs=['ptr = "Hello world!"'])
 
-        self.expect("p strptr",
+        self.expect("expression strptr",
                     substrs=['ptr = "Hello world!"'])
 
         self.expect(
-            "p (char*)\"1234567890123456789012345678901234567890123456789012345678901234ABC\"",
+            "expression (char*)\"1234567890123456789012345678901234567890123456789012345678901234ABC\"",
             substrs=[
                 '(char *) $',
                 ' = ptr = ',
                 '"1234567890123456789012345678901234567890123456789012345678901234ABC"'])
 
         self.runCmd("type summary add -c TestPoint")
 
         self.expect("frame variable iAmSomewhere",

lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py

def data_formatter_commands(self):
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type format delete hex', check=False)
             self.runCmd('type summary clear', check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
-        self.expect('p *(int (*)[3])foo',
+        self.expect('expression *(int (*)[3])foo',
                     substrs=['(int[3]) $', '[0] = 1', '[1] = 2', '[2] = 3'])
 
-        self.expect('p *(int (*)[3])foo', matching=False,
+        self.expect('expression *(int (*)[3])foo', matching=False,
                     substrs=['01 00 00 00 02 00 00 00 03 00 00 00'])
-        self.expect('p *(int (*)[3])foo', matching=False,
+        self.expect('expression *(int (*)[3])foo', matching=False,
                     substrs=['0x000000030000000200000001'])

lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py

# ${var%s}
         self.expect("frame variable strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strarr",
                     substrs=['arr = \"',
                              'Nested Hello world!'])
 
-        self.expect("p strarr",
+        self.expect("expression strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strarr",
+        self.expect("expression other.strarr",
                     substrs=['arr = \"',
                              'Nested Hello world!'])
 
 # ${var%c}
         self.runCmd(
             "type summary add --summary-string \"ptr = ${var%c}\" \"char *\"")
 
         self.expect("frame variable strptr",
                     substrs=['ptr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strptr",
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
-        self.expect("p strptr",
+        self.expect("expression strptr",
                     substrs=['ptr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strptr",
+        self.expect("expression other.strptr",
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
         self.runCmd(
             "type summary add --summary-string \"arr = ${var%c}\" -x \"char\\[[0-9]+\\]\"")
 
         self.expect("frame variable strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strarr",
                     substrs=['arr = \"',
                              'Nested Hello world!'])
 
-        self.expect("p strarr",
+        self.expect("expression strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strarr",
+        self.expect("expression other.strarr",
                     substrs=['arr = \"',
                              'Nested Hello world!'])
 
 # ${var%char[]}
         self.runCmd(
             "type summary add --summary-string \"arr = ${var%char[]}\" -x \"char\\[[0-9]+\\]\"")
 
         self.expect("frame variable strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strarr",
                     substrs=['arr = ',
                              'Nested Hello world!'])
 
-        self.expect("p strarr",
+        self.expect("expression strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strarr",
+        self.expect("expression other.strarr",
                     substrs=['arr = ',
                              'Nested Hello world!'])
 
         self.runCmd(
             "type summary add --summary-string \"ptr = ${var%char[]}\" \"char *\"")
 
         self.expect("frame variable strptr",
                     substrs=['ptr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strptr",
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
-        self.expect("p strptr",
+        self.expect("expression strptr",
                     substrs=['ptr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strptr",
+        self.expect("expression other.strptr",
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
 # ${var%a}
         self.runCmd(
             "type summary add --summary-string \"arr = ${var%a}\" -x \"char\\[[0-9]+\\]\"")
 
         self.expect("frame variable strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strarr",
                     substrs=['arr = ',
                              'Nested Hello world!'])
 
-        self.expect("p strarr",
+        self.expect("expression strarr",
                     substrs=['arr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strarr",
+        self.expect("expression other.strarr",
                     substrs=['arr = ',
                              'Nested Hello world!'])
 
         self.runCmd(
             "type summary add --summary-string \"ptr = ${var%a}\" \"char *\"")
 
         self.expect("frame variable strptr",
                     substrs=['ptr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strptr",
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
-        self.expect("p strptr",
+        self.expect("expression strptr",
                     substrs=['ptr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strptr",
+        self.expect("expression other.strptr",
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
         self.runCmd(
             "type summary add --summary-string \"ptr = ${var[]%char[]}\" \"char *\"")
 
 # I do not know the size of the data, but you are asking for a full array slice..
 # use the ${var%char[]} to obtain a string as result
         self.expect("frame variable strptr", matching=False,
                     substrs=['ptr = \"',
                              'Hello world!'])
 
         self.expect("frame variable other.strptr", matching=False,
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
-        self.expect("p strptr", matching=False,
+        self.expect("expression strptr", matching=False,
                     substrs=['ptr = \"',
                              'Hello world!'])
 
-        self.expect("p other.strptr", matching=False,
+        self.expect("expression other.strptr", matching=False,
                     substrs=['ptr = \"',
                              'Nested Hello world!'])
 
 # You asked an array-style printout...
         self.runCmd(
             "type summary add --summary-string \"ptr = ${var[0-1]%char[]}\" \"char *\"")
 
         self.expect("frame variable strptr",
                     substrs=['ptr = ',
                              '[{H},{e}]'])
 
         self.expect("frame variable other.strptr",
                     substrs=['ptr = ',
                              '[{N},{e}]'])
 
-        self.expect("p strptr",
+        self.expect("expression strptr",
                     substrs=['ptr = ',
                              '[{H},{e}]'])
 
-        self.expect("p other.strptr",
+        self.expect("expression other.strptr",
                     substrs=['ptr = ',
                              '[{N},{e}]'])
 
 # using [] is required here
         self.runCmd(
             "type summary add --summary-string \"arr = ${var%x}\" \"int [5]\"")
 
         self.expect("frame variable intarr", matching=False, substrs=[

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/list/TestDataFormatterGenericList.py

def do_test_with_run_command(self, stdlib_type):
                 substrs=[
                     'size=0',
                     '{}'])
 
         self.expect("frame variable numbers_list",
                     substrs=['size=0',
                              '{}'])
 
-        self.expect("p numbers_list",
+        self.expect("expression numbers_list",
                     substrs=['size=0',
                              '{}'])
 
         self.runCmd("n")
 
         self.expect("frame variable numbers_list",
                     substrs=['size=1',
                              '[0] = ',
def do_test_with_run_command(self, stdlib_type):
                              '0x11223344',
                              '0xbeeffeed',
                              '0x00abba00',
                              '[4] =',
                              '0x0abcdef0',
                              '[5] =',
                              '0x0cab0cab'])
 
-        self.expect("p numbers_list",
+        self.expect("expression numbers_list",
                     substrs=['size=6',
                              '[0] = ',
                              '0x12345678',
                              '0x11223344',
                              '0xbeeffeed',
                              '0x00abba00',
                              '[4] =',
                              '0x0abcdef0',
def do_test_with_run_command(self, stdlib_type):
 
         self.expect("frame variable text_list",
                     substrs=['size=4',
                              '[0]', 'goofy',
                              '[1]', 'is',
                              '[2]', 'smart',
                              '[3]', '!!!'])
 
-        self.expect("p text_list",
+        self.expect("expression text_list",
                     substrs=['size=4',
                              '\"goofy\"',
                              '\"is\"',
                              '\"smart\"',
                              '\"!!!\"'])
 
         # check access-by-index
         self.expect("frame variable text_list[0]",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/multimap/TestDataFormatterGenericMultiMap.py

def do_test_with_run_command(self, stdlib_type):
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
         self.check("ii", 8)
 
-        self.expect("p ii",
+        self.expect("expression ii",
                     substrs=[multimap, 'size=8',
                              '[5] = ',
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
def do_test_with_run_command(self, stdlib_type):
                 multimap,
                 'size=4',
                 '[0] = (first = "one", second = 1)',
                 '[1] = (first = "three", second = 3)',
                 '[2] = (first = "two", second = 2)',
                 '[3] = (first = "zero", second = 0)',
             ])
 
-        self.expect("p si",
+        self.expect("expression si",
                     substrs=[multimap, 'size=4',
                 '[0] = (first = "one", second = 1)',
                 '[1] = (first = "three", second = 3)',
                 '[2] = (first = "two", second = 2)',
                 '[3] = (first = "zero", second = 0)',
             ])
 
         # check that MightHaveChildren() gets it right
def do_test_with_run_command(self, stdlib_type):
                 'size=4',
                 '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")',
             ])
 
         self.expect(
-            "p is",
+            "expression is",
             substrs=[
                 multimap,
                 'size=4',
                 '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")',
             ])
def do_test_with_run_command(self, stdlib_type):
                 '[0] = (first = "casa", second = "house")',
                 '[1] = (first = "ciao", second = "hello")',
                 '[2] = (first = "gatto", second = "cat")',
             ])
 
         self.check("ss", 3)
 
         self.expect(
-            "p ss",
+            "expression ss",
             substrs=[
                 multimap,
                 'size=3',
                 '[0] = (first = "casa", second = "house")',
                 '[1] = (first = "ciao", second = "hello")',
                 '[2] = (first = "gatto", second = "cat")',
             ])
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/multiset/TestDataFormatterGenericMultiSet.py

def do_test_with_run_command(self, stdlib_type):
                 "size=4",
                 '[0] = "a"',
                 '[1] = "a very long string is right here"',
                 '[2] = "b"',
                 '[3] = "c"',
             ])
         self.check("ss", 4)
         self.expect(
-            "p ss",
+            "expression ss",
             substrs=[
                 "size=4",
                 '[0] = "a"',
                 '[1] = "a very long string is right here"',
                 '[2] = "b"',
                 '[3] = "c"',
             ])
         self.expect("frame variable ss[2]", substrs=[' = "b"'])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/set/TestDataFormatterGenericSet.py

def do_test_with_run_command(self,stdlib_type):
         self.expect(
             "frame variable ss",
             substrs=["size=4",
                      '[0] = "a"',
                      '[1] = "a very long string is right here"',
                      '[2] = "b"',
                      '[3] = "c"'])
         self.expect(
-            "p ss",
+            "expression ss",
             substrs=["size=4",
                      '[0] = "a"',
                      '[1] = "a very long string is right here"',
                      '[2] = "b"',
                      '[3] = "c"'])
         self.expect("frame variable ss[2]", substrs=[' = "b"'])
         lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
def do_test_ref_and_ptr(self,stdlib_type):
                     substrs=["size=7"])
 
     @add_test_categories(["libstdcxx"]) 
     def test_ref_and_ptr_libstdcpp(self):
         self.do_test_ref_and_ptr(USE_LIBSTDCPP)
     
     @add_test_categories(["libc++"])
     def test_ref_and_ptr_libcpp(self):
-        self.do_test_ref_and_ptr(USE_LIBCPP)
+        self.do_test_ref_and_ptr(USE_LIBCPP)
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py

def test_with_run_command(self):
                              'first = 2',
                              'second = 0',
                              '[3] = ',
                              'first = 3',
                              'second = 1'])
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
-        self.expect("p ii",
+        self.expect("expression ii",
                     substrs=['%s::map' % ns, 'size=8',
                              '[5] = ',
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
def test_with_run_command(self):
                 'size=4',
                 '[0] = (first = "one", second = 1)',
                 '[1] = (first = "three", second = 3)',
                 '[2] = (first = "two", second = 2)',
                 '[3] = (first = "zero", second = 0)',
             ])
 
         self.expect(
-            "p si",
+            "expression si",
             substrs=[
                 '%s::map' % ns,
                 'size=4',
                 '[0] = (first = "one", second = 1)',
                 '[1] = (first = "three", second = 3)',
                 '[2] = (first = "two", second = 2)',
                 '[3] = (first = "zero", second = 0)',
             ])
def test_with_run_command(self):
                 'size=4',
                 '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")',
             ])
 
         self.expect(
-            "p is",
+            "expression is",
             substrs=[
                 '%s::map' % ns,
                 'size=4',
                 '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")',
             ])
def test_with_run_command(self):
                 '%s::map' % ns,
                 'size=3',
                 '[0] = (first = "casa", second = "house")',
                 '[1] = (first = "ciao", second = "hello")',
                 '[2] = (first = "gatto", second = "cat")',
             ])
 
         self.expect(
-            "p ss",
+            "expression ss",
             substrs=[
                 '%s::map' % ns,
                 'size=3',
                 '[0] = (first = "casa", second = "house")',
                 '[1] = (first = "ciao", second = "hello")',
                 '[2] = (first = "gatto", second = "cat")',
             ])
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py

def test_with_run_command(self):
         self.expect("frame variable numbers",
                     substrs=['numbers = size=4',
                              '[0] = 1',
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '}'])
 
-        self.expect("p numbers",
+        self.expect("expression numbers",
                     substrs=['$', 'size=4',
                              '[0] = 1',
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '}'])
 
         # check access to synthetic children
def test_with_run_command(self):
                              '}'])
 
         # check if we can display strings
         self.expect("frame variable strings",
                     substrs=['goofy',
                              'is',
                              'smart'])
 
-        self.expect("p strings",
+        self.expect("expression strings",
                     substrs=['goofy',
                              'is',
                              'smart'])
 
         # test summaries based on synthetic children
         self.runCmd(
             "type summary add std::string_vect string_vect --summary-string \"vector has ${svar%#} items\" -e")
         self.expect("frame variable strings",
                     substrs=['vector has 3 items',
                              'goofy',
                              'is',
                              'smart'])
 
-        self.expect("p strings",
+        self.expect("expression strings",
                     substrs=['vector has 3 items',
                              'goofy',
                              'is',
                              'smart'])
 
         lldbutil.continue_to_breakpoint(process, bkpt)
 
         self.expect("frame variable strings",
def test_ref_and_ptr(self):
 
         # The reference should display the same was as the value did
         self.check_numbers("ref")
 
         # The pointer should just show the right number of elements:
 
         self.expect("frame variable ptr", substrs=['ptr =', ' size=7'])
 
-        self.expect("p ptr", substrs=['$', 'size=7'])
+        self.expect("expression ptr", substrs=['$', 'size=7'])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py

def test_with_run_command(self):
                     substrs=['map has 9 items',
                              '[5] = ',
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
-        self.expect("p ii",
+        self.expect("expression ii",
                     substrs=['map has 9 items',
                              '[5] = ',
                              'first = 5',
                              'second = 0',
                              '[7] = ',
                              'first = 7',
                              'second = 1'])
 
def test_with_run_command(self):
                 '[0] = (first = "four", second = 4)',
                 '[1] = (first = "one", second = 1)',
                 '[2] = (first = "three", second = 3)',
                 '[3] = (first = "two", second = 2)',
                 '[4] = (first = "zero", second = 0)',
             ])
 
         self.expect(
-            "p si",
+            "expression si",
             substrs=[
                 'map has 5 items',
                 '[0] = (first = "four", second = 4)',
                 '[1] = (first = "one", second = 1)',
                 '[2] = (first = "three", second = 3)',
                 '[3] = (first = "two", second = 2)',
                 '[4] = (first = "zero", second = 0)',
             ])
def test_with_run_command(self):
             substrs=[
                 'map has 4 items', '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")'
             ])
 
         self.expect(
-            "p is",
+            "expression is",
             substrs=[
                 'map has 4 items', '[0] = (first = 1, second = "is")',
                 '[1] = (first = 2, second = "smart")',
                 '[2] = (first = 3, second = "!!!")',
                 '[3] = (first = 85, second = "goofy")'
             ])
 
         # check access-by-index
def test_with_run_command(self):
                 'map has 4 items',
                 '[0] = (first = "a Mac..", second = "..is always a Mac!")',
                 '[1] = (first = "casa", second = "house")',
                 '[2] = (first = "ciao", second = "hello")',
                 '[3] = (first = "gatto", second = "cat")'
             ])
 
         self.expect(
-            "p ss",
+            "expression ss",
             substrs=[
                 'map has 4 items',
                 '[0] = (first = "a Mac..", second = "..is always a Mac!")',
                 '[1] = (first = "casa", second = "house")',
                 '[2] = (first = "ciao", second = "hello")',
                 '[3] = (first = "gatto", second = "cat")'
             ])
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py

def test_with_run_command(self):
         self.expect("frame variable numbers",
                     substrs=['numbers = size=4',
                              '[0] = 1',
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '}'])
 
-        self.expect("p numbers",
+        self.expect("expression numbers",
                     substrs=['$', 'size=4',
                              '[0] = 1',
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '}'])
 
         # check access to synthetic children
def test_with_run_command(self):
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '[4] = 12345',
                              '[5] = 123456',
                              '[6] = 1234567',
                              '}'])
 
-        self.expect("p numbers",
+        self.expect("expression numbers",
                     substrs=['$', 'size=7',
                              '[0] = 1',
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '[4] = 12345',
                              '[5] = 123456',
                              '[6] = 1234567',
def test_with_run_command(self):
         # check if we can display strings
         self.runCmd("c")
 
         self.expect("frame variable strings",
                     substrs=['goofy',
                              'is',
                              'smart'])
 
-        self.expect("p strings",
+        self.expect("expression strings",
                     substrs=['goofy',
                              'is',
                              'smart'])
 
         # test summaries based on synthetic children
         self.runCmd(
             "type summary add std::string_vect string_vect --summary-string \"vector has ${svar%#} items\" -e")
         self.expect("frame variable strings",
                     substrs=['vector has 3 items',
                              'goofy',
                              'is',
                              'smart'])
 
-        self.expect("p strings",
+        self.expect("expression strings",
                     substrs=['vector has 3 items',
                              'goofy',
                              'is',
                              'smart'])
 
         self.runCmd("c")
 
         self.expect("frame variable strings",

lldb/test/API/functionalities/inferior-assert/TestInferiorAssert.py

def check_expr_in_main(self, thread):
             if self.TraceOn():
                 print(
                     "Checking if function %s is main" %
                     frame.GetFunctionName())
 
             if 'main' == frame.GetFunctionName():
                 frame_id = frame.GetFrameID()
                 self.runCmd("frame select " + str(frame_id), RUN_SUCCEEDED)
-                self.expect("p argc", substrs=['(int)', ' = 1'])
-                self.expect("p hello_world", substrs=['Hello'])
-                self.expect("p argv[0]", substrs=['a.out'])
-                self.expect("p null_ptr", substrs=['= 0x0'])
+                self.expect("expression argc", substrs=['(int)', ' = 1'])
+                self.expect("expression hello_world", substrs=['Hello'])
+                self.expect("expression argv[0]", substrs=['a.out'])
+                self.expect("expression null_ptr", substrs=['= 0x0'])
                 return True
         return False
 
     def inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read symbols after asserting."""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.

lldb/test/API/functionalities/inferior-crashing/TestInferiorCrashing.py

def inferior_crashing_expr(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p argc",
+        self.expect("expression argc",
                     startstr='(int) $0 = 1')
 
-        self.expect("p hello_world",
+        self.expect("expression hello_world",
                     substrs=['Hello'])

lldb/test/API/functionalities/inferior-crashing/TestInferiorCrashingStep.py

def inferior_crashing_expr(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p argc", startstr='(int) $0 = 1')
+        self.expect("expression argc", startstr='(int) $0 = 1')
 
-        self.expect("p hello_world", substrs=['Hello'])
+        self.expect("expression hello_world", substrs=['Hello'])
 
     def inferior_crashing_step(self):
         """Test that lldb functions correctly after stepping through a crash."""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.set_breakpoint(self.line)
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect(
             "thread list",
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=['main.c:%d' % self.line, 'stop reason = breakpoint'])
 
         self.runCmd("next")
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p argv[0]", substrs=['a.out'])
-        self.expect("p null_ptr", substrs=['= 0x0'])
+        self.expect("expression argv[0]", substrs=['a.out'])
+        self.expect("expression null_ptr", substrs=['= 0x0'])
 
         # lldb should be able to read from registers from the inferior after
         # crashing.
         lldbplatformutil.check_first_register_readable(self)
 
         # And it should report the correct line number.
         self.expect("thread backtrace all", substrs=['main.c:%d' % self.line])
 
def inferior_crashing_expr_step_expr(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p argv[0]", substrs=['a.out'])
+        self.expect("expression argv[0]", substrs=['a.out'])
 
         self.runCmd("next")
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p argv[0]", substrs=['a.out'])
+        self.expect("expression argv[0]", substrs=['a.out'])

lldb/test/API/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

def recursive_inferior_crashing_expr(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p i",
+        self.expect("expression i",
                     startstr='(int) $0 =')

lldb/test/API/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferiorStep.py

def recursive_inferior_crashing_step(self):
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=['main.c:%d' % self.line, 'stop reason = breakpoint'])
 
         self.runCmd("next")
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p i", substrs=['(int) $0 ='])
+        self.expect("expression i", substrs=['(int) $0 ='])
 
         # lldb should be able to read from registers from the inferior after
         # crashing.
         lldbplatformutil.check_first_register_readable(self)
 
         # And it should report the correct line number.
         self.expect("thread backtrace all", substrs=['main.c:%d' % self.line])
 
def recursive_inferior_crashing_expr_step_expr(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a crash.
-        self.expect("p null", startstr='(char *) $0 = 0x0')
+        self.expect("expression null", startstr='(char *) $0 = 0x0')
 
         self.runCmd("next")
 
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a step.
-        self.expect("p null", startstr='(char *) $1 = 0x0')
+        self.expect("expression null", startstr='(char *) $1 = 0x0')
 
         self.check_stop_reason()

lldb/test/API/functionalities/multiple-slides/TestMultipleSlides.py

def test_mulitple_slides(self):
 
         first_sym = target.FindSymbols("first").GetContextAtIndex(0).GetSymbol()
         second_sym = target.FindSymbols("second").GetContextAtIndex(0).GetSymbol()
         first_size = first_sym.GetEndAddress().GetOffset() - first_sym.GetStartAddress().GetOffset()
         second_size = second_sym.GetEndAddress().GetOffset() - second_sym.GetStartAddress().GetOffset()
 
         # View the first element of `first` and `second` while
         # they have no load address set.
-        self.expect("p/d ((int*)&first)[0]", substrs=['= 5'])
-        self.expect("p/d ((int*)&second)[0]", substrs=['= 6'])
+        self.expect("expression/d ((int*)&first)[0]", substrs=['= 5'])
+        self.expect("expression/d ((int*)&second)[0]", substrs=['= 6'])
         self.assertEqual(first_sym.GetStartAddress().GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
         self.assertEqual(second_sym.GetStartAddress().GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
 
 
         # View the first element of `first` and `second` with
         # no slide applied, but with load address set.
         #
         # In memory, we have something like
         #    0x1000 - 0x17ff  first[]
         #    0x1800 - 0x1fff  second[]
         target.SetModuleLoadAddress(module, 0)
-        self.expect("p/d ((int*)&first)[0]", substrs=['= 5'])
-        self.expect("p/d ((int*)&second)[0]", substrs=['= 6'])
+        self.expect("expression/d ((int*)&first)[0]", substrs=['= 5'])
+        self.expect("expression/d ((int*)&second)[0]", substrs=['= 6'])
         self.assertEqual(first_sym.GetStartAddress().GetLoadAddress(target), 
                          first_sym.GetStartAddress().GetFileAddress())
         self.assertEqual(second_sym.GetStartAddress().GetLoadAddress(target),
                          second_sym.GetStartAddress().GetFileAddress())
 
         # Slide it a little bit less than the size of the first array.
         #
         # In memory, we have something like
         #    0xfc0 - 0x17bf  first[]
         #    0x17c0 - 0x1fbf second[]
         #
         # but if the original entries are still present in lldb, 
         # the beginning address of second[] will get a load address
         # of 0x1800, instead of 0x17c0 (0x1800-64) as we need to get.
         target.SetModuleLoadAddress(module, first_size - 64)
-        self.expect("p/d ((int*)&first)[0]", substrs=['= 5'])
-        self.expect("p/d ((int*)&second)[0]", substrs=['= 6'])
+        self.expect("expression/d ((int*)&first)[0]", substrs=['= 5'])
+        self.expect("expression/d ((int*)&second)[0]", substrs=['= 6'])
         self.assertNotEqual(first_sym.GetStartAddress().GetLoadAddress(target), 
                          first_sym.GetStartAddress().GetFileAddress())
         self.assertNotEqual(second_sym.GetStartAddress().GetLoadAddress(target),
                          second_sym.GetStartAddress().GetFileAddress())
 
         # Slide it back to the original vmaddr.
         target.SetModuleLoadAddress(module, 0)
-        self.expect("p/d ((int*)&first)[0]", substrs=['= 5'])
-        self.expect("p/d ((int*)&second)[0]", substrs=['= 6'])
+        self.expect("expression/d ((int*)&first)[0]", substrs=['= 5'])
+        self.expect("expression/d ((int*)&second)[0]", substrs=['= 6'])
         self.assertEqual(first_sym.GetStartAddress().GetLoadAddress(target), 
                          first_sym.GetStartAddress().GetFileAddress())
         self.assertEqual(second_sym.GetStartAddress().GetLoadAddress(target),
                          second_sym.GetStartAddress().GetFileAddress())
 

lldb/test/API/functionalities/set-data/TestSetData.py

def test_set_data(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("br s -p First")
         self.runCmd("br s -p Second")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
-        self.expect("p myFoo.x", VARIABLES_DISPLAYED_CORRECTLY,
+        self.expect("expression myFoo.x", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['2'])
 
         process = self.dbg.GetSelectedTarget().GetProcess()
         frame = process.GetSelectedThread().GetFrameAtIndex(0)
 
         x = frame.FindVariable("myFoo").GetChildMemberWithName("x")
 
         my_data = lldb.SBData.CreateDataFromSInt32Array(
             lldb.eByteOrderLittle, 8, [4])
         err = lldb.SBError()
 
         self.assertTrue(x.SetData(my_data, err))
 
         self.runCmd("continue")
 
-        self.expect("p myFoo.x", VARIABLES_DISPLAYED_CORRECTLY,
+        self.expect("expression myFoo.x", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['4'])
 
         frame = process.GetSelectedThread().GetFrameAtIndex(0)
 
         x = frame.FindVariable("string")
 
         if process.GetAddressByteSize() == 8:
             my_data = lldb.SBData.CreateDataFromUInt64Array(

lldb/test/API/functionalities/ubsan/user-expression/TestUbsanUserExpression.py

def ubsan_tests(self):
 
         process = self.dbg.GetSelectedTarget().process
         thread = process.GetSelectedThread()
         frame = thread.GetSelectedFrame()
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
-        self.expect("p foo()", substrs=["(int) $0 = 42"])
+        self.expect("expression foo()", substrs=["(int) $0 = 42"])
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])

lldb/test/API/lang/c/enum_types/TestEnumTypes.py

def test_command_line(self):
                     patterns=[' = ALL$'])
         # Test that an enum that doesn't match the heuristic we use in
         # TypeSystemClang::DumpEnumValue, gets printed as a raw integer.
         self.expect("fr var omega", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = 7$'])
         # Test the behavior in case have a variable of a type considered
         # 'bitfield' by the heuristic, but the value isn't actually fully
         # covered by the enumerators.
-        self.expect("p (enum bitfield)nonsense", DATA_TYPES_DISPLAYED_CORRECTLY,
+        self.expect("expression (enum bitfield)nonsense", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=[' = B | C | 0x10$'])
 
         # Break inside the main.
         bkpt_id = lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
         self.runCmd("c", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/lang/c/strings/TestCStrings.py

def test_with_run_command(self):
 
         self.expect("expression -- \"\"[0]",
                     startstr="(const char) $4 = '\\0'")
 
         self.expect("expr --raw -- \"hello\"",
                     substrs=['[0] = \'h\'',
                              '[5] = \'\\0\''])
 
-        self.expect("p \"hello\"",
+        self.expect("expression \"hello\"",
                     substrs=['[6]) $', 'hello'])
 
-        self.expect("p (char*)\"hello\"",
+        self.expect("expression (char*)\"hello\"",
                     substrs=['(char *) $', ' = 0x',
                              'hello'])
 
-        self.expect("p (int)strlen(\"\")",
+        self.expect("expression (int)strlen(\"\")",
                     substrs=['(int) $', ' = 0'])
 
         self.expect("expression !z",
                     substrs=['false'])

lldb/test/API/lang/cpp/namespace/TestNamespace.py

def test_with_run_command(self):
         self.expect_expr("A::B::j", result_value="4")
 
         # expression command with function in anonymous namespace
         self.expect_expr("myanonfunc(3)", result_value="6")
 
         # global namespace qualification with function in anonymous namespace
         self.expect_expr("myanonfunc(4)", result_value="8")
 
-        self.expect("p myanonfunc",
+        self.expect("expression myanonfunc",
                     patterns=['\(anonymous namespace\)::myanonfunc\(int\)'])
 
-        self.expect("p variadic_sum", patterns=[
+        self.expect("expression variadic_sum", patterns=[
                     '\(anonymous namespace\)::variadic_sum\(int, ...\)'])

lldb/test/API/lang/cpp/unique-types4/TestUniqueTypes4.py

 """
 Test that we return only the requested template instantiation.
 """
 
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class UniqueTypesTestCase4(TestBase):
     def do_test(self, debug_flags):
         """Test that we display the correct template instantiation."""
         self.build(dictionary=debug_flags)
         lldbutil.run_to_source_breakpoint(self, "// Set breakpoint here", lldb.SBFileSpec("main.cpp"))
         # FIXME: these should successfully print the values
-        self.expect("print ns::Foo<double>::value", substrs=["no member named"], error=True)
-        self.expect("print ns::Foo<int>::value", substrs=["no member named"], error=True)
-        self.expect("print ns::Bar<double>::value", substrs=["no member named"], error=True)
-        self.expect("print ns::Bar<int>::value", substrs=["no member named"], error=True)
-        self.expect("print ns::FooDouble::value", substrs=["Couldn't lookup symbols"], error=True)
-        self.expect("print ns::FooInt::value", substrs=["Couldn't lookup symbols"], error=True)
+        self.expect("expression ns::Foo<double>::value", substrs=["no member named"], error=True)
+        self.expect("expression ns::Foo<int>::value", substrs=["no member named"], error=True)
+        self.expect("expression ns::Bar<double>::value", substrs=["no member named"], error=True)
+        self.expect("expression ns::Bar<int>::value", substrs=["no member named"], error=True)
+        self.expect("expression ns::FooDouble::value", substrs=["Couldn't lookup symbols"], error=True)
+        self.expect("expression ns::FooInt::value", substrs=["Couldn't lookup symbols"], error=True)
 
     @skipIf(compiler=no_match("clang"))
     @skipIf(compiler_version=["<", "15.0"])
     def test_simple_template_names(self):
         self.do_test(dict(CFLAGS_EXTRAS="-gsimple-template-names"))
 
     @skipIf(compiler=no_match("clang"))
     @skipIf(compiler_version=["<", "15.0"])
     def test_no_simple_template_names(self):
         self.do_test(dict(CFLAGS_EXTRAS="-gno-simple-template-names"))

lldb/test/API/lang/objc/foundation/TestObjCMethodsNSError.py

class FoundationTestCaseNSError(TestBase):
 
     @expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>")
     def test_NSError_p(self):
         """Test that p of the result of an unknown method does require a cast."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
                 self, '// Set break point at this line',
                 lldb.SBFileSpec('main.m', False))
-        self.expect("p [NSError thisMethodIsntImplemented:0]", error=True, patterns=[
+        self.expect("expression [NSError thisMethodIsntImplemented:0]", error=True, patterns=[
                     "no known method", "cast the message send to the method's return type"])
         self.runCmd("process continue")

lldb/test/API/lang/objc/modules-auto-import/TestModulesAutoImport.py

def test_expr(self):
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd("settings set target.auto-import-clang-modules true")
 
-        self.expect("p getpid()", VARIABLES_DISPLAYED_CORRECTLY,
+        self.expect("expression getpid()", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["pid_t"])

lldb/test/API/lang/objc/modules/TestObjCModules.py

def test_expr(self):
 
         self.expect("expr string.length", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["NSUInteger", "5"])
 
         self.expect("expr array.count", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["NSUInteger", "3"])
 
         self.expect(
-            "p *[NSURL URLWithString:@\"http://lldb.llvm.org\"]",
+            "expression *[NSURL URLWithString:@\"http://lldb.llvm.org\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "NSURL",
                 "isa",
                 "_urlString"])
 
         self.expect(
-            "p [NSURL URLWithString:@\"http://lldb.llvm.org\"].scheme",
+            "expression [NSURL URLWithString:@\"http://lldb.llvm.org\"].scheme",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["http"])
         # Test that the NULL macro still works with a loaded module.
         self.expect_expr("int *i = NULL; i == NULL", result_value="true")

lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py

def test_with_python_api(self):
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
         self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
-        self.expect("p [summer sumThings:tts]", substrs=['9'])
+        self.expect("expression [summer sumThings:tts]", substrs=['9'])
 
         self.expect(
             "po [NSValue valueWithRect:rect]",
             substrs=['NSRect: {{0, 0}, {10, 20}}'])
 
         # Now make sure we can call a method that returns a struct without
         # crashing.
         cmd_value = frame.EvaluateExpression("[provider getRange]")
         self.assertTrue(cmd_value.IsValid())

lldb/test/API/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py

def test_method_ret_BOOL(self):
             "process status",
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=[
                 "stop reason = breakpoint",
                 " at %s:%d" % (self.main_source, self.line),
             ])
 
         # rdar://problem/9691614
-        self.runCmd('p (int)[my isValid]')
+        self.runCmd('expression (int)[my isValid]')

lldb/test/API/linux/aarch64/non_address_bit_memory_access/TestAArch64LinuxNonAddressBitMemoryAccess.py

def test_non_address_bit_memory_caching(self):
         # happen.
         log_file = self.getBuildArtifact("lldb-non-address-bit-log.txt")
         # This defaults to overwriting the file so we don't need to delete
         # any existing files.
         self.runCmd("log enable gdb-remote packets -f '%s'" % log_file)
 
         # This should fill the cache by doing a read of buf_with_non_address
         # with the non-address bits removed (which is == buf).
-        self.runCmd("p buf_with_non_address")
+        self.runCmd("expression buf_with_non_address")
         # This will read from the cache since the two pointers point to the
         # same place.
-        self.runCmd("p buf")
+        self.runCmd("expression buf")
 
         # Open log ignoring utf-8 decode errors
         with open(log_file, 'r', errors='ignore') as f:
             read_packet = "send packet: $x{:x}"
 
             # Since we allocated a 4k page that page will be aligned to 4k, which
             # also fits the 512 byte line size of the memory cache. So we can expect
             # to find a packet with its exact address.

lldb/test/API/linux/builtin_trap/TestBuiltinTrap.py

def test_with_run_command(self):
 
         # print backtrace, expect both 'bar' and 'main' functions to be listed
         self.expect('bt', substrs=['bar', 'main'])
 
         # go up one frame
         self.runCmd("up", RUN_SUCCEEDED)
 
         # evaluate a local
-        self.expect('p foo', substrs=['= 5'])
+        self.expect('expression foo', substrs=['= 5'])

lldb/test/API/lua_api/TestFileHandle.lua

function _T:TestLegacyFileOutScript()
     f = io.open(self.output, 'r')
     assertEquals(read_file_non_empty_lines(f), {'2', 'FOO'})
     f:close()
 end
 
 function _T:TestLegacyFileOut()
     local f = io.open(self.output, 'w')
     self.debugger:SetOutputFile(f)
-    self:handle_command('p/x 3735928559', false)
+    self:handle_command('expression/x 3735928559', false)
     f:close()
 
     f = io.open(self.output, 'r')
     assertStrContains(f:read('*l'), 'deadbeef')
     f:close()
 end
 
 function _T:TestLegacyFileErr()

lldb/test/API/macosx/early-process-launch/TestEarlyProcessLaunch.py

def test_early_process_launch(self):
             self, 'malloc')
 
         target.DisableAllBreakpoints()
         target.BreakpointCreateByName("main")
 
         logfile_early = os.path.join(self.getBuildDir(), "types-log-early.txt")
         self.addTearDownHook(lambda: self.runCmd("log disable lldb types"))
         self.runCmd("log enable -f %s lldb types" % logfile_early)
-        self.runCmd("p global = 15")
+        self.runCmd("expression global = 15")
 
         err = process.Continue()
         self.assertTrue(err.Success())
 
         logfile_later = os.path.join(self.getBuildDir(), "types-log-later.txt")
         self.runCmd("log enable -f %s lldb types" % logfile_later)
-        self.runCmd("p global = 25")
+        self.runCmd("expression global = 25")
 
         self.assertTrue(os.path.exists(logfile_early))
         self.assertTrue(os.path.exists(logfile_later))
         early_text = open(logfile_early).read()
         later_text = open(logfile_later).read()
 
         self.assertIn("ran: no, retry: yes", early_text)
         self.assertNotIn("ran: no, retry: yes", later_text)
 
         self.assertNotIn("ran: yes, retry: no", early_text)
         self.assertIn("ran: yes, retry: no", later_text)

lldb/test/API/macosx/macCatalyst/TestMacCatalyst.py

def test_macabi(self):
         log = self.getBuildArtifact('packets.log')
         self.expect("log enable gdb-remote packets -f "+log)
         lldbutil.run_to_source_breakpoint(self, "break here",
                                           lldb.SBFileSpec('main.c'))
         self.expect("image list -t -b",
                     patterns=[self.getArchitecture() +
                               r'.*-apple-ios.*-macabi a\.out'])
         self.expect("fr v s", substrs=["Hello macCatalyst"])
-        self.expect("p s", substrs=["Hello macCatalyst"])
+        self.expect("expression s", substrs=["Hello macCatalyst"])
         self.check_debugserver(log)
 
     def check_debugserver(self, log):
         """scan the debugserver packet log"""
         process_info = lldbutil.packetlog_get_process_info(log)
         self.assertIn('ostype', process_info)
         self.assertEquals(process_info['ostype'], 'maccatalyst')
 
         aout_info = None
         dylib_info = lldbutil.packetlog_get_dylib_info(log)
         for image in dylib_info['images']:
             if image['pathname'].endswith('a.out'):
                 aout_info = image
         self.assertTrue(aout_info)
         self.assertEquals(aout_info['min_version_os_name'], 'maccatalyst')

lldb/test/API/macosx/macCatalystAppMacOSFramework/TestMacCatalystAppWithMacOSFramework.py

def test(self):
         self.expect("log enable gdb-remote packets -f "+log)
         lldbutil.run_to_source_breakpoint(self, "break here",
                                           lldb.SBFileSpec('main.c'))
         arch = self.getArchitecture()
         self.expect("image list -t -b",
                     patterns=[arch + r'.*-apple-ios.*-macabi a\.out',
                               arch + r'.*-apple-macosx.* libfoo.dylib[^(]'])
         self.expect("fr v s", "Hello macCatalyst")
-        self.expect("p s", "Hello macCatalyst")
+        self.expect("expression s", "Hello macCatalyst")
         self.check_debugserver(log)
 
     def check_debugserver(self, log):
         """scan the debugserver packet log"""
         process_info = lldbutil.packetlog_get_process_info(log)
         self.assertIn('ostype', process_info)
         self.assertEquals(process_info['ostype'], 'maccatalyst')
 

lldb/test/API/python_api/file_handle/TestFileHandle.py

def test_legacy_file_out_script(self):
             self.dbg.GetOutputFileHandle().flush()
         with open(self.out_filename, 'r') as f:
             self.assertEqual(readStrippedLines(f), ['2', 'FOO'])
 
 
     def test_legacy_file_out(self):
         with open(self.out_filename, 'w') as f:
             self.dbg.SetOutputFileHandle(f, False)
-            self.handleCmd('p/x 3735928559', collect_result=False, check=False)
+            self.handleCmd('expression/x 3735928559', collect_result=False, check=False)
         with open(self.out_filename, 'r') as f:
             self.assertIn('deadbeef', f.read())
 
     def test_legacy_file_err_with_get(self):
         with open(self.out_filename, 'w') as f:
             self.dbg.SetErrorFileHandle(f, False)
             self.handleCmd('lolwut', check=False, collect_result=False)
             f2 = self.dbg.GetErrorFileHandle()
def test_binary_inout(self):
             self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
             self.dbg.GetOutputFile().Flush()
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
 
 
     def test_string_inout(self):
-        inf = io.StringIO("help help\np/x ~0\n")
+        inf = io.StringIO("help help\nexpression/x ~0\n")
         outf = io.StringIO()
         status = self.dbg.SetOutputFile(lldb.SBFile(outf))
         self.assertSuccess(status)
         status = self.dbg.SetInputFile(lldb.SBFile(inf))
         self.assertSuccess(status)
         opts = lldb.SBCommandInterpreterRunOptions()
         self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
         self.dbg.GetOutputFile().Flush()

lldb/test/API/types/TestRecursiveTypes.py

def print_struct(self):
             self,
             "recursive_type_main.cpp",
             self.line,
             num_expected_locations=-1,
             loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
-        self.runCmd("print tpi")
-        self.runCmd("print *tpi")
+        self.runCmd("expression tpi")
+        self.runCmd("expression *tpi")