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

[kastiglione]

Summary

In Shell 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.

See also D141539 which made the same change to API tests.

[JDevlieghere]

LGTM. I probably would've gone with expo but as expression is the canonical name of the command, this makes sense.

[kastiglione]

I probably would've gone with expr

I had it as expr at first and changed it to expression, since that's what I had done in D141539. I'm down to change it to expr, I think it's probably fine too.

lldb/test/Shell/Commands/command-source.test

 # Check that stop command source on error.
 
 # RUN: not %lldb -x -b -o "command source -e 1 %s" 2>&1 | FileCheck %s --check-prefix STOP
 # RUN: %lldb -x -b -o "command source -e 0 %s" 2>&1 | FileCheck %s --check-prefix CONTINUE
 # RUN: not %lldb -x -b -o 'settings set interpreter.stop-command-source-on-error true' -o "command source %s" 2>&1 | FileCheck %s --check-prefix STOP
 # RUN: %lldb -x -b -o 'settings set interpreter.stop-command-source-on-error false' -o "command source %s" 2>&1 | FileCheck %s --check-prefix CONTINUE
 
 bogus
-p 10+1
+expression 10+1
 
 # CONTINUE: $0 = 11
 # STOP-NOT: $0 = 11

lldb/test/Shell/Commands/command-stop-hook-no-target.test

 # RUN: %clang_host -g %S/Inputs/main.c -o %t
-# RUN: %lldb -b -o 'target stop-hook add --name test --shlib test -o "p 95000 + 126"' -o 'file %t' -o 'b main' -o 'r' 2>&1 | FileCheck %s
+# RUN: %lldb -b -o 'target stop-hook add --name test --shlib test -o "expression 95000 + 126"' -o 'file %t' -o 'b main' -o 'r' 2>&1 | FileCheck %s
 # CHECK: Stop hook #1 added
 # CHECK-NOT: 95126

lldb/test/Shell/Expr/nodefaultlib.cpp

 // Test that we're able to evaluate expressions in inferiors without the
 // standard library (and mmap-like functions in particular).
 
 // REQUIRES: native
 // UNSUPPORTED: ld_preload-present
 // XFAIL: system-linux && !(target-x86 || target-x86_64)
 // XFAIL: system-netbsd || system-freebsd || system-darwin
 
 // RUN: %build %s --nodefaultlib -o %t
-// RUN: %lldb %t -o "b main" -o run -o "p call_me(5, 6)" -o exit \
+// RUN: %lldb %t -o "b main" -o run -o "expression call_me(5, 6)" -o exit \
 // RUN:   | FileCheck %s
 
-// CHECK: p call_me(5, 6)
+// CHECK: expression call_me(5, 6)
 // CHECK: (int) $0 = 30
 
 int call_me(int x, long y) { return x * y; }
 
 int main() { return call_me(4, 5); }

lldb/test/Shell/Register/x86-64-fp-read.test

 # XFAIL: system-windows
 # Darwin uses the legacy behavior of reporting abridged ftag value,
 # it is covered by TestRegisters.py::fp_special_purpose_register_read.
 # XFAIL: system-darwin
 # REQUIRES: native && target-x86_64
 # RUN: %clangxx_host -g %p/Inputs/x86-fp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 # CHECK: Process {{.*}} stopped
 
 # fdiv (%rbx) gets encoded into 2 bytes, int3 into 1 byte
-print (void*)($pc-3)
+expression (void*)($pc-3)
 # CHECK: (void *) $0 = [[FDIV:0x[0-9a-f]*]]
-print &zero
+expression &zero
 # CHECK: (uint32_t *) $1 = [[ZERO:0x[0-9a-f]*]]
 
 register read --all
 # CHECK-DAG: fctrl = 0x037b
 # CHECK-DAG: fstat = 0x8084
 # CHECK-DAG: ftag = 0xea58
 # CHECK-DAG: fop = 0x0033
 # CHECK-DAG: fip = [[FDIV]]
 # CHECK-DAG: fdp = [[ZERO]]
 
 # CHECK-DAG: st{{(mm)?}}0 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 0x00 0x40}
 # CHECK-DAG: st{{(mm)?}}1 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x3f 0x00 0x00}
 # CHECK-DAG: st{{(mm)?}}2 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}
 # CHECK-DAG: st{{(mm)?}}3 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80}
 # CHECK-DAG: st{{(mm)?}}4 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 0xff 0x7f}
 # CHECK-DAG: st{{(mm)?}}5 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 0xff 0xff}
 # CHECK-DAG: st{{(mm)?}}6 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xc0 0xff 0xff}
 # CHECK-DAG: st{{(mm)?}}7 = {0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}
 
 # legacy approach, superseded by fip/fdp registers
-print (void*)($fiseg*0x100000000 + $fioff)
+expression (void*)($fiseg*0x100000000 + $fioff)
 # CHECK: (void *) $2 = [[FDIV]]
-print (uint32_t*)($foseg * 0x100000000 + $fooff)
+expression (uint32_t*)($foseg * 0x100000000 + $fooff)
 # CHECK: (uint32_t *) $3 = [[ZERO]]
 
 process continue
 # CHECK: Process {{[0-9]+}} exited with status = 0

lldb/test/Shell/Register/x86-db-read.test

 # CHECK: Watchpoint created: Watchpoint 1: addr = 0x{{[0-9a-f]*}} size = 1 state = enabled type = w
 watchpoint set variable -w read_write g_16rw
 # CHECK: Watchpoint created: Watchpoint 2: addr = 0x{{[0-9a-f]*}} size = 2 state = enabled type = rw
 watchpoint set variable -w write g_32w
 # CHECK: Watchpoint created: Watchpoint 3: addr = 0x{{[0-9a-f]*}} size = 4 state = enabled type = w
 watchpoint set variable -w read_write g_32rw
 # CHECK: Watchpoint created: Watchpoint 4: addr = 0x{{[0-9a-f]*}} size = 4 state = enabled type = rw
 
-print &g_8w
+expression &g_8w
 # CHECK: (uint8_t *) $0 = [[VAR8W:0x[0-9a-f]*]]
-print &g_16rw
+expression &g_16rw
 # CHECK: (uint16_t *) $1 = [[VAR16RW:0x[0-9a-f]*]]
-print &g_32w
+expression &g_32w
 # CHECK: (uint32_t *) $2 = [[VAR32W:0x[0-9a-f]*]]
-print &g_32rw
+expression &g_32rw
 # CHECK: (uint32_t *) $3 = [[VAR64RW:0x[0-9a-f]*]]
 
 register read --all
 # CHECK-DAG: dr0 = [[VAR8W]]
 # CHECK-DAG: dr1 = [[VAR16RW]]
 # CHECK-DAG: dr2 = [[VAR32W]]
 # CHECK-DAG: dr3 = [[VAR64RW]]
 # CHECK-DAG: dr6 = 0x{{(00000000)?}}ffff0ff0
 # CHECK-DAG: dr7 = 0x{{(00000000)?}}fd7104aa
 
 process continue
 # CHECK: Process {{[0-9]+}} exited with status = 0

lldb/test/Shell/Register/x86-fp-read.test

 # XFAIL: system-windows
 # Darwin uses the legacy behavior of reporting abridged ftag value,
 # it is covered by TestRegisters.py::fp_special_purpose_register_read.
 # XFAIL: system-darwin
 # REQUIRES: native && target-x86
 # RUN: %clangxx_host -g %p/Inputs/x86-fp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 # CHECK: Process {{.*}} stopped
 
 # fdiv (%rbx) gets encoded into 2 bytes, int3 into 1 byte
-print (void*)($pc-3)
+expression (void*)($pc-3)
 # CHECK: (void *) $0 = [[FDIV:0x[0-9a-f]*]]
-print &zero
+expression &zero
 # CHECK: (uint32_t *) $1 = [[ZERO:0x[0-9a-f]*]]
 
 register read --all
 # CHECK-DAG: fctrl = 0x037b
 # CHECK-DAG: fstat = 0x8084
 # CHECK-DAG: ftag = 0xea58
 # CHECK-DAG: fop = 0x0033
 # CHECK-DAG: fioff = [[FDIV]]

lldb/test/Shell/Settings/Inputs/DontStopCommandSource.in

 settings set interpreter.stop-command-source-on-error false
 bogus
-print 123400000 + 56789
+expression 123400000 + 56789

lldb/test/Shell/Settings/Inputs/StopCommandSource.in

 settings set interpreter.stop-command-source-on-error true
 bogus
-print 123400000 + 56789
+expression 123400000 + 56789

lldb/test/Shell/Settings/TestStopCommandSourceOnError.test

 # Modifying the interpreter settings is tricky because they don't take effect
 # until we create a new command interpreter, which should be merely an
 # implementation detail. This leads to confusing and unexpected scenarios.
 #
 # Below are a few scenarios that we should fix.
 
 # CONTINUE: 123456789
 # STOP-NOT: 111111111
 # STOP-NOT: 123456789
 
 # FIXME: Should stop
 # RUN: %lldb -b -o 'settings set interpreter.stop-command-source-on-error false' -s %S/Inputs/StopCommandSource.in | FileCheck %s --check-prefix CONTINUE
 
 # FIXME: Should continue
-# RUN: not %lldb -b -s %S/Inputs/DontStopCommandSource.in -o 'bogus' -o 'print 111100000 + 11111' | FileCheck %s --check-prefix STOP
+# RUN: not %lldb -b -s %S/Inputs/DontStopCommandSource.in -o 'bogus' -o 'expression 111100000 + 11111' | FileCheck %s --check-prefix STOP
 
 # FIXME: Should continue
-# RUN: not %lldb -b -o 'settings set interpreter.stop-command-source-on-error false' -o 'bogus' -o 'print 123400000 + 56789'  | FileCheck %s --check-prefix STOP
+# RUN: not %lldb -b -o 'settings set interpreter.stop-command-source-on-error false' -o 'bogus' -o 'expression 123400000 + 56789'  | FileCheck %s --check-prefix STOP
 
 # FIXME: Should continue
 # RUN: not %lldb -b -s %S/Inputs/DontStopCommandSource.in | FileCheck %s --check-prefix STOP
 
 # FIXME: Should continue
 # RUN: not %lldb -b -o 'settings set interpreter.stop-command-source-on-error true' -s %S/Inputs/DontStopCommandSource.in | FileCheck %s --check-prefix STOP

lldb/test/Shell/SymbolFile/DWARF/debug-types-expressions.test

 
 frame variable *a
 # CHECK-LABEL: frame variable *a
 # CHECK:      (B) *a = {
 # CHECK-NEXT:   A = (i = 47)
 # CHECK-NEXT:   j = 42
 # CHECK-NEXT: }
 
-print a->f()
-# CHECK-LABEL: print a->f()
+expression a->f()
+# CHECK-LABEL: expression a->f()
 # CHECK: (int) $0 = 47
 
-print ns::A()
-# CHECK-LABEL: print ns::A()
+expression ns::A()
+# CHECK-LABEL: expression ns::A()
 # CHECK: (ns::A) $1 = (i = 147)
 
-print ns::A().i + a->i
-# CHECK-LABEL: print ns::A().i + a->i
+expression ns::A().i + a->i
+# CHECK-LABEL: expression ns::A().i + a->i
 # CHECK: (int) $2 = 194
 
-print ns::A().getA()
+expression ns::A().getA()
 # CHECK-LABEL: ns::A().getA()
 # CHECK: (A) $3 = (i = 146)

lldb/test/Shell/SymbolFile/DWARF/split-dwarf-expression-eval-bug.cpp

 // This tests a crash which occured under very specific circumstances. The
 // interesting aspects of this test are:
 // - we print a global variable from one compile unit
 // - we are stopped in a member function of a class in a namespace
 // - that namespace is also present in a third file, which also has a global
 //   variable
 
 // UNSUPPORTED: system-darwin, system-windows
 
 // RUN: %clang_host -c -gsplit-dwarf -g %s -o %t1.o -DONE
 // RUN: %clang_host -c -gsplit-dwarf -g %s -o %t2.o -DTWO
 // RUN: %clang_host -c -gsplit-dwarf -g %s -o %t3.o -DTHREE
 // RUN: %clang_host %t1.o %t2.o %t3.o -o %t
-// RUN: %lldb %t -o "br set -n foo" -o run -o "p bool_in_first_cu" -o exit \
+// RUN: %lldb %t -o "br set -n foo" -o run -o "expression bool_in_first_cu" -o exit \
 // RUN:   | FileCheck %s
 
-// CHECK: (lldb) p bool_in_first_cu
+// CHECK: (lldb) expression bool_in_first_cu
 // CHECK: (bool) $0 = true
 
 
 #if defined(ONE)
 bool bool_in_first_cu = true;
 #elif defined(TWO)
 bool bool_in_second_cu = true;
 

lldb/test/Shell/SymbolFile/DWARF/x86/DW_TAG_GNU_call_site-DW_AT_low_pc.s

 # This tests that lldb is compatible with DWARF-4 entry values GNU extension
 # with DW_TAG_GNU_call_site attributes order as produced by GCC:
 # 0x000000b1:     DW_TAG_GNU_call_site
 #                   DW_AT_low_pc  (0x000000000040111e)
 #                   DW_AT_abstract_origin (0x000000cc "a")
 # clang produces the attributes in opposite order:
 # 0x00000064:     DW_TAG_GNU_call_site
 #                   DW_AT_abstract_origin (0x0000002a "a")
 #                   DW_AT_low_pc  (0x0000000000401146)
 
 # REQUIRES: target-x86_64, system-linux, lld
 
 # RUN: %clang_host -o %t %s
-# RUN: %lldb %t -o r -o 'p p' -o exit | FileCheck %s
+# RUN: %lldb %t -o r -o 'expression p' -o exit | FileCheck %s
 
 # CHECK: (int) $0 = 1
 
 # The DWARF has been produced and modified from:
 # static __attribute__((noinline, noclone)) void b(int x) {
 #   asm("");
 # }
 # static __attribute__((noinline, noclone)) void a(int p) {

lldb/test/Shell/SymbolFile/DWARF/x86/DW_TAG_variable-DW_AT_const_value.s

 # This tests that lldb is able to print DW_TAG_variable using DW_AT_const_value.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux-gnu %s -filetype=obj > %t.o
-# RUN: %lldb %t.o -o "p/x magic64" -o exit | FileCheck %s
+# RUN: %lldb %t.o -o "expression/x magic64" -o exit | FileCheck %s
 
 # CHECK: (const long) $0 = 0xed9a924c00011151
 
 # The DW_TAG_variable using DW_AT_const_value can be compiled from:
 # static const long magic64 = 0xed9a924c00011151;
 # int main(void) { return magic64; }
 
   .text

lldb/test/Shell/SymbolFile/DWARF/x86/debug-types-basic.test

 type lookup EC
 # CHECK-LABEL: type lookup EC
 # CHECK:      enum class EC {
 # CHECK-NEXT:   e1,
 # CHECK-NEXT:   e2,
 # CHECK-NEXT:   e3
 # CHECK-NEXT: }
 
-print (E) 1
-# CHECK-LABEL: print (E) 1
+expression (E) 1
+# CHECK-LABEL: expression (E) 1
 # CHECK: (E) $0 = e2
 
-print (EC) 1
-# CHECK-LABEL: print (EC) 1
+expression (EC) 1
+# CHECK-LABEL: expression (EC) 1
 # CHECK: (EC) $1 = e2
 
 target variable a e ec
 # CHECK-LABEL: target variable a e ec
 # CHECK: (const A) a = (i = 42, l = 47, f = 4.{{[12].*}}, d = 4.{{[67].*}}, e = e1, ec = e3)
 # CHECK: (const E) e = e2
 # CHECK: (const EC) ec = e2

lldb/test/Shell/SymbolFile/DWARF/x86/debug-types-missing-signature.test

 Create a dangling DW_AT_signature reference by stripping the debug_types
 section, and make sure lldb does something reasonable.
 RUN: %clangxx -target x86_64-pc-linux %S/Inputs/debug-types-basic.cpp \
 RUN:   -g -gdwarf-4 -fdebug-types-section -c -o %t.o
 RUN: llvm-objcopy --remove-section=.debug_types %t.o %t
 
 
 RUN: %lldb %t -b -o "type lookup A" | FileCheck --check-prefix=LOOKUPA %s
 LOOKUPA: no type was found matching 'A'
 
 RUN: %lldb %t -b -o "type lookup E" | FileCheck --check-prefix=LOOKUPE %s
 LOOKUPE: no type was found matching 'E'
 
 RUN: %lldb %t -b -o "type lookup EC" | FileCheck --check-prefix=LOOKUPEC %s
 LOOKUPEC: no type was found matching 'EC'
 
-RUN: not %lldb %t -b -o "print (E) 1" 2>&1 | FileCheck --check-prefix=PRINTE %s
+RUN: not %lldb %t -b -o "expression (E) 1" 2>&1 | FileCheck --check-prefix=PRINTE %s
 PRINTE: use of undeclared identifier 'E'
 
-RUN: not %lldb %t -b -o "print (EC) 1" 2>&1 | FileCheck --check-prefix=PRINTEC %s
+RUN: not %lldb %t -b -o "expression (EC) 1" 2>&1 | FileCheck --check-prefix=PRINTEC %s
 PRINTEC: use of undeclared identifier 'EC'
 
 RUN: %lldb %t -b -o "target variable a e ec" | FileCheck --check-prefix=VARS %s
 VARS: (const (unnamed struct)) a = {}
 VARS: (const (unnamed enum)) e = 0x1
 VARS: (const (unnamed enum)) ec = 0x1

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-line-strp.s

 # Test handling of DWARF5 DW_FORM_line_strp from .debug_info as used by GCC.
 
 # UNSUPPORTED: system-darwin, system-windows
 
 # RUN: llvm-mc -filetype=obj -o %t -triple x86_64-pc-linux %s
-# RUN: %lldb %t -o "p main" \
+# RUN: %lldb %t -o "expression main" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK: (void (*)()) $0 = 0x0000000000000000
 
   .text
 .Ltext0:
   .globl  main
   .type main, @function

lldb/test/Shell/SymbolFile/DWARF/x86/limit-debug-info.s

 # REQUIRES: lld
 # RUN: llvm-mc --triple=x86_64-pc-windows --filetype=obj --defsym DLL=0 %s >%t.dll.o
 # RUN: llvm-mc --triple=x86_64-pc-windows --filetype=obj --defsym EXE=0 %s >%t.exe.o
 # RUN: lld-link /OUT:%t.dll %t.dll.o /SUBSYSTEM:console /dll /noentry /debug
 # RUN: lld-link /OUT:%t.exe %t.exe.o /SUBSYSTEM:console /debug /force
-# RUN: %lldb %t.exe -o "target modules add %t.dll" -o "p var" \
+# RUN: %lldb %t.exe -o "target modules add %t.dll" -o "expression var" \
 # RUN:   -o exit 2>&1 | FileCheck %s
 
-# CHECK: (lldb) p var
+# CHECK: (lldb) expression var
 # CHECK: (A) $0 = (member = 47)
 
         .section        .debug_abbrev,"dr"
 .Lsection_abbrev:
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   1                       # DW_CHILDREN_yes
         .byte   37                      # DW_AT_producer

lldb/test/Shell/SymbolFile/NativePDB/Inputs/inline_sites_live.lldbinit

 br set -p BP_bar -f inline_sites_live.cpp
 br set -p BP_foo -f inline_sites_live.cpp
 run
-p param
+expression param
 continue
-p param
-p local
+expression param
+expression local

lldb/test/Shell/SymbolFile/NativePDB/Inputs/local-variables.lldbinit

 break set -f local-variables.cpp -l 17
 run a b c d e f g
-p argc
+expression argc
 step
-p SomeLocal
+expression SomeLocal
 step
-p Param1
-p Param2
+expression Param1
+expression Param2
 step
-p Param1
-p Param2
-p Local1
-step
-p Param1
-p Param2
-p Local1
-p Local2
-step
-p Param1
-p Param2
-p Local1
-p Local2
-step
-p Param1
-p Param2
-p Local1
-p Local2
+expression Param1
+expression Param2
+expression Local1
+step
+expression Param1
+expression Param2
+expression Local1
+expression Local2
+step
+expression Param1
+expression Param2
+expression Local1
+expression Local2
+step
+expression Param1
+expression Param2
+expression Local1
+expression Local2
 continue
 
 target modules dump ast
 
 quit

lldb/test/Shell/SymbolFile/NativePDB/incomplete-tag-type.cpp

 // clang-format off
 // REQUIRES: lld, x86
 
 // RUN: %clang_cl --target=x86_64-windows-msvc -c /Fo%t1.obj -- %p/Inputs/incomplete-tag-type.cpp
 // RUN: %clang_cl --target=x86_64-windows-msvc /O1 /Z7 -c /Fo%t2.obj -- %s
 // RUN: lld-link /debug:full /nodefaultlib /entry:main %t1.obj %t2.obj /out:%t.exe /pdb:%t.pdb
 // RUN: env LLDB_USE_NATIVE_PDB_READER=1 %lldb -f %t.exe -o \
 // RUN:   "settings set interpreter.stop-command-source-on-error false" \
-// RUN:   -o "p b" -o "p d" -o "p static_e_ref" -o "exit" 2>&1 | FileCheck %s
+// RUN:   -o "expression b" -o "expr d" -o "expr static_e_ref" -o "exit" 2>&1 | FileCheck %s
 
-// CHECK: (lldb) p b
+// CHECK: (lldb) expression b
 // CHECK: (B) $0 = {}
-// CHECK: (lldb) p d
+// CHECK: (lldb) expression d
 // CHECK: (D) $1 = {}
-// CHECK: (lldb) p static_e_ref
+// CHECK: (lldb) expression static_e_ref
 // CHECK: error: expression failed to parse:
 // CHECK: error: {{.*}}: incomplete type 'E' where a complete type is required
 // CHECK: static_e_ref
 // CHECK: ^
 
 // Complete base class.
 struct A { int x; A(); };
 struct B : A {};

lldb/test/Shell/SymbolFile/NativePDB/inline_sites_live.cpp

 }
 
 int main(int argc, char** argv) {
   foo(argc);
 }
 
 // CHECK:      * thread #1, stop reason = breakpoint 1
 // CHECK-NEXT:    frame #0: {{.*}}`main [inlined] bar(param=2)
-// CHECK:      (lldb) p param
+// CHECK:      (lldb) expression param
 // CHECK-NEXT: (int) $0 = 2
 // CHECK:      * thread #1, stop reason = breakpoint 2
 // CHECK-NEXT:    frame #0: {{.*}}`main [inlined] foo(param=1)
-// CHECK:      (lldb) p param
+// CHECK:      (lldb) expression param
 // CHECK-NEXT: (int) $1 = 1
-// CHECK-NEXT: (lldb) p local
+// CHECK-NEXT: (lldb) expression local
 // CHECK-NEXT: (int) $2 = 2

lldb/test/Shell/SymbolFile/NativePDB/local-variables.cpp

 // CHECK-NEXT:    15
 // CHECK-NEXT:    16   int main(int argc, char **argv) {
 // CHECK-NEXT: -> 17     int SomeLocal = argc * 2;
 // CHECK-NEXT:    18     return Function(SomeLocal, 'a');
 // CHECK-NEXT:    19   }
 // CHECK-NEXT:    20
 
 // CHECK:      Process {{.*}} launched: '{{.*}}local-variables.cpp.tmp.exe'
-// CHECK-NEXT: (lldb) p argc
+// CHECK-NEXT: (lldb) expression argc
 // CHECK-NEXT: (int) $0 = 8
 // CHECK-NEXT: (lldb) step
 // CHECK-NEXT: Process {{.*}} stopped
 // CHECK-NEXT: * thread #1, stop reason = step in
 // CHECK-NEXT:     frame #0: {{.*}} local-variables.cpp.tmp.exe`main(argc=8, argv={{.*}}) at local-variables.cpp:{{.*}}
 // CHECK-NEXT:    15
 // CHECK-NEXT:    16 int main(int argc, char **argv) {
 // CHECK-NEXT:    17     int SomeLocal = argc * 2;
 // CHECK-NEXT: -> 18     return Function(SomeLocal, 'a');
 // CHECK-NEXT:    19 }
 // CHECK-NEXT:    20
 
-// CHECK:      (lldb) p SomeLocal
+// CHECK:      (lldb) expression SomeLocal
 // CHECK-NEXT: (int) $1 = 16
 // CHECK-NEXT: (lldb) step
 // CHECK-NEXT: Process {{.*}} stopped
 // CHECK-NEXT: * thread #1, stop reason = step in
 // CHECK-NEXT:     frame #0: {{.*}} local-variables.cpp.tmp.exe`Function(Param1=16, Param2='a') at local-variables.cpp:{{.*}}
 // CHECK-NEXT:    6
 // CHECK-NEXT:    7
 // CHECK-NEXT:    8 int Function(int Param1, char Param2) {
 // CHECK-NEXT: -> 9      unsigned Local1 = Param1 + 1;
 // CHECK-NEXT:    10     char Local2 = Param2 + 1;
 // CHECK-NEXT:    11     ++Local1;
 // CHECK-NEXT:    12     ++Local2;
 
-// CHECK:      (lldb) p Param1
+// CHECK:      (lldb) expression Param1
 // CHECK-NEXT: (int) $2 = 16
-// CHECK-NEXT: (lldb) p Param2
+// CHECK-NEXT: (lldb) expression Param2
 // CHECK-NEXT: (char) $3 = 'a'
 // CHECK-NEXT: (lldb) step
 // CHECK-NEXT: Process {{.*}} stopped
 // CHECK-NEXT: * thread #1, stop reason = step in
 // CHECK-NEXT:     frame #0: {{.*}} local-variables.cpp.tmp.exe`Function(Param1=16, Param2='a') at local-variables.cpp:{{.*}}
 // CHECK-NEXT:    7
 // CHECK-NEXT:    8    int Function(int Param1, char Param2) {
 // CHECK-NEXT:    9      unsigned Local1 = Param1 + 1;
 // CHECK-NEXT: -> 10     char Local2 = Param2 + 1;
 // CHECK-NEXT:    11     ++Local1;
 // CHECK-NEXT:    12     ++Local2;
 // CHECK-NEXT:    13     return Local1;
 
-// CHECK:      (lldb) p Param1
+// CHECK:      (lldb) expression Param1
 // CHECK-NEXT: (int) $4 = 16
-// CHECK-NEXT: (lldb) p Param2
+// CHECK-NEXT: (lldb) expression Param2
 // CHECK-NEXT: (char) $5 = 'a'
-// CHECK-NEXT: (lldb) p Local1
+// CHECK-NEXT: (lldb) expression Local1
 // CHECK-NEXT: (unsigned int) $6 = 17
 // CHECK-NEXT: (lldb) step
 // CHECK-NEXT: Process {{.*}} stopped
 // CHECK-NEXT: * thread #1, stop reason = step in
 // CHECK-NEXT:     frame #0: {{.*}} local-variables.cpp.tmp.exe`Function(Param1=16, Param2='a') at local-variables.cpp:{{.*}}
 // CHECK-NEXT:    8    int Function(int Param1, char Param2) {
 // CHECK-NEXT:    9      unsigned Local1 = Param1 + 1;
 // CHECK-NEXT:    10     char Local2 = Param2 + 1;
 // CHECK-NEXT: -> 11     ++Local1;
 // CHECK-NEXT:    12     ++Local2;
 // CHECK-NEXT:    13     return Local1;
 // CHECK-NEXT:    14   }
 
-// CHECK:      (lldb) p Param1
+// CHECK:      (lldb) expression Param1
 // CHECK-NEXT: (int) $7 = 16
-// CHECK-NEXT: (lldb) p Param2
+// CHECK-NEXT: (lldb) expression Param2
 // CHECK-NEXT: (char) $8 = 'a'
-// CHECK-NEXT: (lldb) p Local1
+// CHECK-NEXT: (lldb) expression Local1
 // CHECK-NEXT: (unsigned int) $9 = 17
-// CHECK-NEXT: (lldb) p Local2
+// CHECK-NEXT: (lldb) expression Local2
 // CHECK-NEXT: (char) $10 = 'b'
 // CHECK-NEXT: (lldb) step
 // CHECK-NEXT: Process {{.*}} stopped
 // CHECK-NEXT: * thread #1, stop reason = step in
 // CHECK-NEXT:     frame #0: {{.*}} local-variables.cpp.tmp.exe`Function(Param1=16, Param2='a') at local-variables.cpp:{{.*}}
 // CHECK-NEXT:    9      unsigned Local1 = Param1 + 1;
 // CHECK-NEXT:    10     char Local2 = Param2 + 1;
 // CHECK-NEXT:    11     ++Local1;
 // CHECK-NEXT: -> 12     ++Local2;
 // CHECK-NEXT:    13     return Local1;
 // CHECK-NEXT:    14   }
 // CHECK-NEXT:    15
 
-// CHECK:      (lldb) p Param1
+// CHECK:      (lldb) expression Param1
 // CHECK-NEXT: (int) $11 = 16
-// CHECK-NEXT: (lldb) p Param2
+// CHECK-NEXT: (lldb) expression Param2
 // CHECK-NEXT: (char) $12 = 'a'
-// CHECK-NEXT: (lldb) p Local1
+// CHECK-NEXT: (lldb) expression Local1
 // CHECK-NEXT: (unsigned int) $13 = 18
-// CHECK-NEXT: (lldb) p Local2
+// CHECK-NEXT: (lldb) expression Local2
 // CHECK-NEXT: (char) $14 = 'b'
 // CHECK-NEXT: (lldb) step
 // CHECK-NEXT: Process {{.*}} stopped
 // CHECK-NEXT: * thread #1, stop reason = step in
 // CHECK-NEXT:     frame #0: {{.*}} local-variables.cpp.tmp.exe`Function(Param1=16, Param2='a') at local-variables.cpp:{{.*}}
 // CHECK-NEXT:    10      char Local2 = Param2 + 1;
 // CHECK-NEXT:    11     ++Local1;
 // CHECK-NEXT:    12     ++Local2;
 // CHECK-NEXT: -> 13     return Local1;
 // CHECK-NEXT:    14   }
 // CHECK-NEXT:    15
 // CHECK-NEXT:    16   int main(int argc, char **argv) {
 
-// CHECK:      (lldb) p Param1
+// CHECK:      (lldb) expression Param1
 // CHECK-NEXT: (int) $15 = 16
-// CHECK-NEXT: (lldb) p Param2
+// CHECK-NEXT: (lldb) expression Param2
 // CHECK-NEXT: (char) $16 = 'a'
-// CHECK-NEXT: (lldb) p Local1
+// CHECK-NEXT: (lldb) expression Local1
 // CHECK-NEXT: (unsigned int) $17 = 18
-// CHECK-NEXT: (lldb) p Local2
+// CHECK-NEXT: (lldb) expression Local2
 // CHECK-NEXT: (char) $18 = 'c'
 // CHECK-NEXT: (lldb) continue
 // CHECK-NEXT: Process {{.*}} resuming
 // CHECK-NEXT: Process {{.*}} exited with status = 18 (0x00000012)
 
 // CHECK:      (lldb) target modules dump ast
 // CHECK-NEXT: Dumping clang ast for {{.*}} modules.
 // CHECK-NEXT: TranslationUnitDecl
 // CHECK-NEXT: |-FunctionDecl {{.*}} main 'int (int, char **)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} argc 'int'
 // CHECK-NEXT: | `-ParmVarDecl {{.*}} argv 'char **'
 // CHECK-NEXT: |-FunctionDecl {{.*}} __scrt_common_main_seh 'int ()' static 
 // CHECK-NEXT: |-FunctionDecl {{.*}} invoke_main 'int ()' inline
 // CHECK: `-FunctionDecl {{.*}} Function 'int (int, char)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} Param1 'int'
 // CHECK-NEXT:   `-ParmVarDecl {{.*}} Param2 'char'

lldb/test/Shell/SymbolFile/PDB/Inputs/ExpressionsTest0.script

 breakpoint set --file ExpressionsTest.cpp --line 19
 run
-print result
-print N0::N1::sum(N0::N1::buf1, sizeof(N0::N1::buf1))
-print N1::sum(N1::buf1, sizeof(N1::buf1))
-print sum(buf1, sizeof(buf1))
-print sum(buf1, 1000000000)
+expression result
+expression N0::N1::sum(N0::N1::buf1, sizeof(N0::N1::buf1))
+expression N1::sum(N1::buf1, sizeof(N1::buf1))
+expression sum(buf1, sizeof(buf1))
+expression sum(buf1, 1000000000)

lldb/test/Shell/SymbolFile/PDB/Inputs/ExpressionsTest1.script

-print sum(buf0, 1)
+expression sum(buf0, 1)

lldb/test/Shell/SymbolFile/PDB/Inputs/ExpressionsTest2.script

-print sum(buf0, result - 28)
-print sum(buf1 + 3, 3)
+expression sum(buf0, result - 28)
+expression sum(buf1 + 3, 3)

lldb/test/Shell/SymbolFile/PDB/Inputs/VBases.script

 breakpoint set --file VBases.cpp --line 15
 
 run
 
-print c
+expression c
 
-frame variable c
+frame variable c
 

lldb/test/Shell/SymbolFile/PDB/expressions.test

 REQUIRES: system-windows, msvc
 RUN: %build --compiler=msvc --nodefaultlib --output=%t.exe %S/Inputs/ExpressionsTest.cpp
 RUN: not %lldb -b -s %S/Inputs/ExpressionsTest0.script -s %S/Inputs/ExpressionsTest1.script -s %S/Inputs/ExpressionsTest2.script -- %t.exe 2>&1 | FileCheck %s
 
-// Check the variable value through `print`
-CHECK: (lldb) print result
+// Check the variable value through `expression`
+CHECK: (lldb) expression result
 CHECK: (char) $0 = '\x1c'
 
 // Call the function just like in the code
-CHECK: (lldb) print N0::N1::sum(N0::N1::buf1, sizeof(N0::N1::buf1))
+CHECK: (lldb) expression N0::N1::sum(N0::N1::buf1, sizeof(N0::N1::buf1))
 CHECK: (char) $1 = '\x1c'
 
 // Try the relaxed namespaces search
-CHECK: (lldb) print N1::sum(N1::buf1, sizeof(N1::buf1))
+CHECK: (lldb) expression N1::sum(N1::buf1, sizeof(N1::buf1))
 CHECK: (char) $2 = '\x1c'
 
 // Try the relaxed variables and functions search
-CHECK: (lldb) print sum(buf1, sizeof(buf1))
+CHECK: (lldb) expression sum(buf1, sizeof(buf1))
 CHECK: (char) $3 = '\x1c'
 
 // Make a crash during expression calculation
-CHECK: (lldb) print sum(buf1, 1000000000)
+CHECK: (lldb) expression sum(buf1, 1000000000)
 CHECK: The process has been returned to the state before expression evaluation.
 
 // Make one more crash
-CHECK: (lldb) print sum(buf0, 1)
+CHECK: (lldb) expression sum(buf0, 1)
 CHECK: The process has been returned to the state before expression evaluation.
 
 // Check if the process state was restored succesfully
-CHECK: (lldb) print sum(buf0, result - 28)
+CHECK: (lldb) expression sum(buf0, result - 28)
 CHECK: (char) $4 = '\0'
 
 // Call the function with arbitrary parameters
-CHECK: (lldb) print sum(buf1 + 3, 3)
+CHECK: (lldb) expression sum(buf1 + 3, 3)
 CHECK: (char) $5 = '\f'