[nongnu] elpa/raku-mode 8f6804ad17 207/253: Merge pull request #26 from matiaslina/raku-rename

[ELPA Syncer]

branch: elpa/raku-mode
commit 8f6804ad172d342808d2ba74eed0a29a3a6cb8b8
Merge: 0be91cc76e 04f458529e
Author: Matias Linares <matiaslina@gmail.com>
Commit: GitHub <noreply@github.com>

    Merge pull request #26 from matiaslina/raku-rename
    
    Rename to raku-mode
---
 Cask                                          |   2 +-
 Makefile                                      |   2 +-
 README.md                                     |  26 +-
 nqp-mode.el                                   |  44 +--
 perl6-detect.el => raku-detect.el             |  39 +--
 perl6-font-lock.el => raku-font-lock.el       | 388 +++++++++++++-------------
 perl6-imenu.el => raku-imenu.el               |  64 ++---
 perl6-indent.el => raku-indent.el             |  26 +-
 perl6-mode.el => raku-mode.el                 |  72 ++---
 perl6-repl.el => raku-repl.el                 |  60 ++--
 perl6-unicode-menu.el => raku-unicode-menu.el |   4 +-
 test/perl6-mode-test.el                       | 122 --------
 test/raku-mode-test.el                        | 122 ++++++++
 test/test-helper.el                           |   4 +-
 test/test-imenu.nqp                           |   4 +-
 test/test-imenu.p6                            |   4 +-
 test/test-smie.p6                             |   2 +-
 17 files changed, 493 insertions(+), 492 deletions(-)

diff --git a/Cask b/Cask
index 11d566d6ec..19ab894445 100644
--- a/Cask
+++ b/Cask
@@ -1,7 +1,7 @@
 (source gnu)
 (source melpa)
 
-(package-file "perl6-mode.el")
+(package-file "raku-mode.el")
 
 (files "*.el")
 
diff --git a/Makefile b/Makefile
index bbfae9c377..110b756ec6 100644
--- a/Makefile
+++ b/Makefile
@@ -15,7 +15,7 @@ OBJS = $(SRCS:.el=.elc)
 compile: $(OBJS)
 
 clean:
-       rm -rf $(OBJS) dist perl6-mode-pkg.el
+       rm -rf $(OBJS) dist raku-mode-pkg.el
 
 test: $(PKGDIR)
        $(CASK) exec ert-runner $(TESTFLAGS)
diff --git a/README.md b/README.md
index f29a55d074..ba1946c083 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# Perl 6 Mode
+# Raku Mode
 
 [![License GPL 3][badge-license]][copying]
 [![MELPA 
Status](http://melpa.org/packages/perl6-mode-badge.svg)](http://melpa.org/#/perl6-mode)
 [![travis][badge-travis]][travis]
 
-Perl 6 mode lets you edit Perl 6 code with [GNU Emacs][] 24.
+Raku mode lets you edit Raku code with [GNU Emacs][] 24.
 
 This mode needs GNU Emacs 24.4.
 
@@ -34,7 +34,7 @@ This mode needs GNU Emacs 24.4.
 With [`use-package`][use-package] in your init file:
 
 ```el
-(use-package perl6-mode
+(use-package raku-mode
   :ensure t
   :defer t)
 ```
@@ -44,21 +44,21 @@ Or in your [`Cask`][cask] file:
 ```el
 (source melpa)
 
-(depends-on "perl6-mode")
+(depends-on "raku-mode")
 ```
 Or manually from [MELPA][] with <kbd>M-x package-refresh-contents</kbd>
-and <kbd>M-x package-install RET perl6-mode</kbd>.
+and <kbd>M-x package-install RET raku-mode</kbd>.
 
 ## Usage
 
-Just visit Perl 6 files.
+Just visit Raku files.
 
-The major mode will be autoloaded whenever a Perl 6 file is visited.
-This includes any file with `perl6` in the shebang, as well as any file
+The major mode will be autoloaded whenever a Raku file is visited.
+This includes any file with `raku` in the shebang, as well as any file
 with a `.p6`, `.pm6`, or `.pl6` extension. It also applies to any `.pm`,
-`.pl`, and `.t` files whose first line of code looks like Perl 6.
+`.pl`, and `.t` files whose first line of code looks like Raku.
 
-Start the REPL with <kbd>M-x run-perl6 RET</kbd>. The following
+Start the REPL with <kbd>M-x run-raku RET</kbd>. The following
 keybindings are available to interact with the REPL:
 
 * <kbd>C-c C-c</kbd>: Send the current line to the REPL
@@ -67,7 +67,7 @@ keybindings are available to interact with the REPL:
 
 The REPL will start if needed with this keybindings.
 
-Use <kbd>M-x customize-group RET perl6</kbd> to customize Perl 6 Mode.
+Use <kbd>M-x customize-group RET raku</kbd> to customize Raku Mode.
 
 ## Contribute
 
@@ -83,12 +83,12 @@ The original version of this code can be found at
 
 ## License
 
-Perl 6 Mode is free software: you can redistribute it and/or modify it
+Raku Mode is free software: you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation, either version 3 of the License, or (at your
 option) any later version.
 
-Perl 6 Mode is distributed in the hope that it will be useful, but
+Raku Mode is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
 Public License for more details.
diff --git a/nqp-mode.el b/nqp-mode.el
index d5b2d24e76..197c45a615 100644
--- a/nqp-mode.el
+++ b/nqp-mode.el
@@ -1,4 +1,4 @@
-;;; perl6-mode.el --- Major mode for editing Perl 6 code -*- lexical-binding: 
t; -*-
+;;; raku-mode.el --- Major mode for editing Raku code -*- lexical-binding: t; 
-*-
 
 ;; Copyright (C) 2015  Hinrik Örn Sigurðsson <hinrik.sig@gmail.com>
 
@@ -25,7 +25,7 @@
 
 ;;; Commentary:
 
-;; GNU Emacs 24 major mode for editing Perl 6 code.
+;; GNU Emacs 24 major mode for editing Raku code.
 
 ;; Currently only provides very basic syntax highlighting.
 
@@ -33,28 +33,28 @@
 
 (declare-function pkg-info-version-info "pkg-info" (library))
 
-(defgroup perl6 nil
-  "Major mode for editing Perl 6 code."
-  :prefix "perl6-"
+(defgroup raku nil
+  "Major mode for editing Raku code."
+  :prefix "raku-"
   :group 'language)
 
-(require 'perl6-detect)
-(require 'perl6-font-lock)
-(require 'perl6-indent)
-(require 'perl6-imenu)
+(require 'raku-detect)
+(require 'raku-font-lock)
+(require 'raku-indent)
+(require 'raku-imenu)
 
 ;;;###autoload
-(define-derived-mode perl6-mode prog-mode "Perl6"
-  "Major mode for editing Perl 6 code."
+(define-derived-mode raku-mode prog-mode "Raku"
+  "Major mode for editing Raku code."
   ;; Syntaxification and font locking
-  (setq-local syntax-propertize-function #'perl6-syntax-propertize)
+  (setq-local syntax-propertize-function #'raku-syntax-propertize)
   (add-hook 'syntax-propertize-extend-region-functions 
#'syntax-propertize-multiline nil 'local)
-  (setq-local font-lock-syntactic-face-function 
#'perl6-font-lock-syntactic-face)
-  (setq-local font-lock-defaults '(perl6-font-lock-keywords nil nil))
-  ;; Add imenu support for perl6-mode.  Note that imenu-generic-expression
+  (setq-local font-lock-syntactic-face-function 
#'raku-font-lock-syntactic-face)
+  (setq-local font-lock-defaults '(raku-font-lock-keywords nil nil))
+  ;; Add imenu support for raku-mode.  Note that imenu-generic-expression
   ;; is buffer-local, so we don't need a local-variable for it.
-  (add-hook 'perl6-mode-hook 'imenu-add-menubar-index)
-  (setq imenu-generic-expression perl6-imenu-generic-expression
+  (add-hook 'raku-mode-hook 'imenu-add-menubar-index)
+  (setq imenu-generic-expression raku-imenu-generic-expression
       imenu-case-fold-search nil)
   ;; Comments
   (setq-local comment-start "#")
@@ -62,15 +62,15 @@
   (setq-local comment-use-syntax t)
   (setq-local comment-end "")
   ;; Indentation
-  (smie-setup perl6-smie-grammar #'perl6-smie-rules
-              :forward-token #'perl6-smie--forward-token
-              :backward-token #'perl6-smie--backward-token))
+  (smie-setup raku-smie-grammar #'raku-smie-rules
+              :forward-token #'raku-smie--forward-token
+              :backward-token #'raku-smie--backward-token))
 
-(provide 'perl6-mode)
+(provide 'raku-mode)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-mode.el ends here
+;;; raku-mode.el ends here
diff --git a/perl6-detect.el b/raku-detect.el
similarity index 51%
rename from perl6-detect.el
rename to raku-detect.el
index e4c4d684a2..9b4b97c1e1 100644
--- a/perl6-detect.el
+++ b/raku-detect.el
@@ -1,26 +1,27 @@
-;;; perl6-detect.el --- Perl 6 detection -*- lexical-binding: t; -*-
+;;; raku-detect.el --- Raku detection -*- lexical-binding: t; -*-
 
 ;;; Commentary:
 
-;; Yes, we are adding to `magic-mode-alist' here. Perl 6 uses the same
+;; Yes, we are adding to `magic-mode-alist' here. Raku uses the same
 ;; file extensions as Perl 5, and we want the mode to work out of the box.
 ;; So for those files we look at the first line of code to determine
-;; whether to call `perl6-mode' instead of `perl-mode'.
+;; whether to call `raku-mode' instead of `perl-mode'.
 
 ;;; Code:
 
 ;;;###autoload
-(add-to-list 'interpreter-mode-alist '("perl6" . perl6-mode))
+(add-to-list 'interpreter-mode-alist '("perl6" . raku-mode))
+(add-to-list 'interpreter-mode-alist '("raku" . raku-mode))
 
 ;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.p[lm]?6\\'" . perl6-mode))
-(add-to-list 'auto-mode-alist '("\\.nqp\\'"     . perl6-mode))
-(add-to-list 'auto-mode-alist '("\\.raku\\'"    . perl6-mode))
-(add-to-list 'auto-mode-alist '("\\.rakumod\\'" . perl6-mode))
-(add-to-list 'auto-mode-alist '("\\.rakutest\\'" . perl6-mode))
+(add-to-list 'auto-mode-alist '("\\.p[lm]?6\\'" . raku-mode))
+(add-to-list 'auto-mode-alist '("\\.nqp\\'"     . raku-mode))
+(add-to-list 'auto-mode-alist '("\\.raku\\'"    . raku-mode))
+(add-to-list 'auto-mode-alist '("\\.rakumod\\'" . raku-mode))
+(add-to-list 'auto-mode-alist '("\\.rakutest\\'" . raku-mode))
 
 ;;;###autoload
-(defconst perl6-magic-pattern
+(defconst raku-magic-pattern
   (rx line-start
       (0+ space)
       (or (and "use" (1+ space) "v6")
@@ -28,36 +29,36 @@
                (or "module" "class" "role" "grammar" "enum" "slang" 
"subset")))))
 
 ;;;###autoload
-(defun perl6-magic-matcher ()
-  "Check if the current buffer is a Perl 6 file.
+(defun raku-magic-matcher ()
+  "Check if the current buffer is a Raku file.
 
 Only looks at a buffer if it has a file extension of .t, .pl, or .pm.
 
 Scans the buffer (to a maximum of 4096 chars) for the first non-comment,
-non-whitespace line.  Returns t if that line looks like Perl 6 code,
+non-whitespace line.  Returns t if that line looks like Raku code,
 nil otherwise."
   (let ((case-fold-search nil))
     (when (and (stringp buffer-file-name)
                (string-match "\\.\\(?:t\\|p[lm]\\)\\'" buffer-file-name))
       (let ((keep-going t)
-            (found-perl6 nil)
+            (found-raku nil)
             (max-pos (min 4096 (point-max))))
         (while (and (< (point) max-pos)
                     keep-going)
           (if (looking-at "^ *\\(?:#.*\\)?$")
               (beginning-of-line 2)
             (setq keep-going nil
-                  found-perl6 (looking-at perl6-magic-pattern))))
-        found-perl6))))
+                  found-raku (looking-at raku-magic-pattern))))
+        found-raku))))
 
 ;;;###autoload
-(add-to-list 'magic-mode-alist '(perl6-magic-matcher . perl6-mode))
+(add-to-list 'magic-mode-alist '(raku-magic-matcher . raku-mode))
 
-(provide 'perl6-detect)
+(provide 'raku-detect)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-detect.el ends here
+;;; raku-detect.el ends here
diff --git a/perl6-font-lock.el b/raku-font-lock.el
similarity index 69%
rename from perl6-font-lock.el
rename to raku-font-lock.el
index 8a97dc8fb4..65f17c392b 100644
--- a/perl6-font-lock.el
+++ b/raku-font-lock.el
@@ -1,4 +1,4 @@
-;;; perl6-font-lock.el --- Font locking and syntax propertizing for Perl 6 -*- 
lexical-binding: t; -*-
+;;; raku-font-lock.el --- Font locking and syntax propertizing for Raku -*- 
lexical-binding: t; -*-
 
 ;;; Commentary:
 
@@ -6,106 +6,106 @@
 
 ;;; Code:
 
-(defface perl6-identifier '((t :inherit default))
-  "Face for identifiers in Perl 6."
-  :group 'perl6-faces)
+(defface raku-identifier '((t :inherit default))
+  "Face for identifiers in Raku."
+  :group 'raku-faces)
 
-(defface perl6-number '((t :inherit font-lock-constant-face))
-  "Face for number literals in Perl 6."
-  :group 'perl6-faces)
+(defface raku-number '((t :inherit font-lock-constant-face))
+  "Face for number literals in Raku."
+  :group 'raku-faces)
 
-(defface perl6-number-addition '((t :inherit font-lock-type-face))
+(defface raku-number-addition '((t :inherit font-lock-type-face))
   "Face for additional characters attached to numbers."
-  :group 'perl6-faces)
+  :group 'raku-faces)
 
-(defface perl6-string '((t :inherit font-lock-string-face))
-  "Face for strings in Perl 6."
-  :group 'perl6-faces)
+(defface raku-string '((t :inherit font-lock-string-face))
+  "Face for strings in Raku."
+  :group 'raku-faces)
 
-(defface perl6-comment '((t :inherit font-lock-comment-face))
-  "Face for comments in Perl 6."
-  :group 'perl6-faces)
+(defface raku-comment '((t :inherit font-lock-comment-face))
+  "Face for comments in Raku."
+  :group 'raku-faces)
 
-(defface perl6-operator '((t :inherit font-lock-builtin-face))
-  "Face for operators in Perl 6."
-  :group 'perl6-faces)
+(defface raku-operator '((t :inherit font-lock-builtin-face))
+  "Face for operators in Raku."
+  :group 'raku-faces)
 
-(defface perl6-type '((t :inherit font-lock-type-face))
-  "Face for types in Perl 6."
-  :group 'perl6-faces)
+(defface raku-type '((t :inherit font-lock-type-face))
+  "Face for types in Raku."
+  :group 'raku-faces)
 
-(defface perl6-phaser '((t :inherit font-lock-preprocessor-face))
-  "Face for phasers in Perl 6."
-  :group 'perl6-faces)
+(defface raku-phaser '((t :inherit font-lock-preprocessor-face))
+  "Face for phasers in Raku."
+  :group 'raku-faces)
 
-(defface perl6-exception '((t :inherit font-lock-keyword-face))
-  "Face for exception keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-exception '((t :inherit font-lock-keyword-face))
+  "Face for exception keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-declare '((t :inherit font-lock-keyword-face))
-  "Face for declaration keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-declare '((t :inherit font-lock-keyword-face))
+  "Face for declaration keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-include '((t :inherit font-lock-keyword-face))
-  "Face for include keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-include '((t :inherit font-lock-keyword-face))
+  "Face for include keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-conditional '((t :inherit font-lock-keyword-face))
-  "Face for conditional keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-conditional '((t :inherit font-lock-keyword-face))
+  "Face for conditional keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-scope '((t :inherit font-lock-keyword-face))
-  "Face for scope keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-scope '((t :inherit font-lock-keyword-face))
+  "Face for scope keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-loop '((t :inherit font-lock-keyword-face))
-  "Face for loop keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-loop '((t :inherit font-lock-keyword-face))
+  "Face for loop keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-flow-control '((t :inherit font-lock-keyword-face))
-  "Face for flow control keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-flow-control '((t :inherit font-lock-keyword-face))
+  "Face for flow control keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-pragma '((t :inherit font-lock-keyword-face))
-  "Face for pragmas in Perl 6."
-  :group 'perl6-faces)
+(defface raku-pragma '((t :inherit font-lock-keyword-face))
+  "Face for pragmas in Raku."
+  :group 'raku-faces)
 
-(defface perl6-type-constraint '((t :inherit font-lock-preprocessor-face))
-  "Face for type constraint keywords in Perl 6."
-  :group 'perl6-faces)
+(defface raku-type-constraint '((t :inherit font-lock-preprocessor-face))
+  "Face for type constraint keywords in Raku."
+  :group 'raku-faces)
 
-(defface perl6-type-property '((t :inherit font-lock-builtin-face))
-  "Face for type constraint properties in Perl 6."
-  :group 'perl6-faces)
+(defface raku-type-property '((t :inherit font-lock-builtin-face))
+  "Face for type constraint properties in Raku."
+  :group 'raku-faces)
 
-(defface perl6-sigil '((t :inherit font-lock-variable-name-face))
-  "Face for variable sigils in Perl 6."
-  :group 'perl6-faces)
+(defface raku-sigil '((t :inherit font-lock-variable-name-face))
+  "Face for variable sigils in Raku."
+  :group 'raku-faces)
 
-(defface perl6-twigil '((t :inherit font-lock-type-face))
-  "Face for variable twigils in Perl 6."
-  :group 'perl6-faces)
+(defface raku-twigil '((t :inherit font-lock-type-face))
+  "Face for variable twigils in Raku."
+  :group 'raku-faces)
 
-(defface perl6-var-package '((t :inherit font-lock-constant-face))
-  "Face for variable names in Perl 6."
-  :group 'perl6-faces)
+(defface raku-var-package '((t :inherit font-lock-constant-face))
+  "Face for variable names in Raku."
+  :group 'raku-faces)
 
-(defface perl6-var-name '((t :inherit font-lock-variable-name-face))
-  "Face for variable names in Perl 6."
-  :group 'perl6-faces)
+(defface raku-var-name '((t :inherit font-lock-variable-name-face))
+  "Face for variable names in Raku."
+  :group 'raku-faces)
 
-(defface perl6-version '((t :inherit font-lock-constant-face))
-  "Face for version literals in Perl 6."
-  :group 'perl6-faces)
+(defface raku-version '((t :inherit font-lock-constant-face))
+  "Face for version literals in Raku."
+  :group 'raku-faces)
 
-(defface perl6-label '((t :inherit font-lock-constant-face))
-  "Face for block labels in Perl 6."
-  :group 'perl6-faces)
+(defface raku-label '((t :inherit font-lock-constant-face))
+  "Face for block labels in Raku."
+  :group 'raku-faces)
 
 (eval-when-compile
   (require 'rx)
 
-  (defun perl6-rx-symbol (form)
+  (defun raku-rx-symbol (form)
     "Translate FORM into a regular expression."
     (let ((body (cdr form)))
       (rx-to-string `(and symbol-start ,@body symbol-end) 'no-group)))
@@ -120,8 +120,8 @@
                                (and (any "@%$")
                                     (regex 
"[^.?^=_[:alpha:]]\[\{\('\"[:space:]]")
                                     (0+ (regex "[^\[\{\('\"[:space:]]")))))))
-    (defconst perl6-rx-constituents
-      `((symbol perl6-rx-symbol 0 nil)
+    (defconst raku-rx-constituents
+      `((symbol raku-rx-symbol 0 nil)
         (identifier . ,rx-identifier)
         (variable
          . ,(rx-to-string
@@ -255,9 +255,9 @@
                      (group-n 2 "d")
                      (group-n 3 (regex "[[:digit:]]") (0+ (regex 
"[[:digit:]_]"))))))))))
 
-  (defmacro perl6-rx (&rest sexps)
-    "Specialized `rx' variant for perl6-mode."
-    (let ((rx-constituents (append perl6-rx-constituents rx-constituents)))
+  (defmacro raku-rx (&rest sexps)
+    "Specialized `rx' variant for raku-mode."
+    (let ((rx-constituents (append raku-rx-constituents rx-constituents)))
       (cond ((null sexps)
              (error "No regexp"))
             ((cdr sexps)
@@ -265,7 +265,7 @@
             (t
              (rx-to-string (car sexps) t))))))
 
-(defconst perl6-mode-syntax-table
+(defconst raku-mode-syntax-table
   (let ((table (make-syntax-table)))
     ;; single-quoted strings
     (modify-syntax-entry ?' "\"" table)
@@ -282,10 +282,10 @@
     (modify-syntax-entry ?> "." table)
     (modify-syntax-entry ?| "." table)
     table)
-  "The top level syntax table for Perl 6.")
+  "The top level syntax table for Raku.")
 
-(defconst perl6-bracket-syntax-table
-  (let ((table (make-syntax-table perl6-mode-syntax-table)))
+(defconst raku-bracket-syntax-table
+  (let ((table (make-syntax-table raku-mode-syntax-table)))
     (modify-syntax-entry ?< "(>" table)
     (modify-syntax-entry ?> ")<" table)
     (modify-syntax-entry ?« "(»" table)
@@ -297,7 +297,7 @@
     table)
   "Syntax table for bracketing constructs.")
 
-(defun perl6-syntax-context (&optional state)
+(defun raku-syntax-context (&optional state)
   "Return the syntactic context at the parse state of STATE.
 
 If STATE is not provided, the return value of `syntax-ppss' will be used."
@@ -309,7 +309,7 @@ If STATE is not provided, the return value of `syntax-ppss' 
will be used."
        (in-comment 'comment)
        (t nil))))
 
-(defun perl6-forward-brackets (open close length)
+(defun raku-forward-brackets (open close length)
   "Move point past the end of a bracketed structure.
 
 Skips over any nested balanced brackets.
@@ -335,14 +335,14 @@ LENGTH is the length of the brackets (e.g. 2 for a 
<<foo>>)."
                (when (eq depth 0)
                  (setq found-closing t))))))))
 
-(defun perl6-syntax-propertize-delimiters (syntax &optional offset)
+(defun raku-syntax-propertize-delimiters (syntax &optional offset)
   "Add syntax properties to a delimited region.
 
 SYNTAX is the type of syntax to apply to the delimiters \(such as \"!\"\).
 
 OFFSET can be used to shift the starting position (relative to point) of the
 opening delimiter."
-  (with-syntax-table perl6-bracket-syntax-table
+  (with-syntax-table raku-bracket-syntax-table
     (when (and (following-char)
                (eq ?\( (char-syntax (following-char))))
       (let* ((delim-beg (+ (point) (or offset 0)))
@@ -352,19 +352,19 @@ opening delimiter."
                            'syntax-table (string-to-syntax syntax))
         (re-search-forward (rx-to-string `(1+ ,open-delim)))
         (let ((delim-length (length (match-string 0))))
-          (perl6-forward-brackets open-delim close-delim delim-length)
+          (raku-forward-brackets open-delim close-delim delim-length)
           (let ((delim-end (point)))
             (put-text-property delim-beg delim-end 'syntax-multiline t)
             (put-text-property (- delim-end 1) delim-end
                                'syntax-table (string-to-syntax syntax)))))
       t)))
 
-(defun perl6-syntax-propertize-comment (limit)
+(defun raku-syntax-propertize-comment (limit)
   "Add syntax properties to comments."
   (unless (save-excursion
             (and (re-search-forward "\\=[`|=]" (1+ (point)) t)
                   ;; embedded/multiline comment
-                 (perl6-syntax-propertize-delimiters "!" -2)))
+                 (raku-syntax-propertize-delimiters "!" -2)))
     ;; single-line comment
     (put-text-property (1- (point)) (point)
                        'syntax-table (string-to-syntax "<"))
@@ -372,11 +372,11 @@ opening delimiter."
         (put-text-property (1- (point)) (point)
                            'syntax-table (string-to-syntax ">")))))
 
-(defun perl6-syntax-propertize-angles (open-angles)
+(defun raku-syntax-propertize-angles (open-angles)
   "Add syntax properties to angle-bracketed quotes (e.g. <foo> and «bar»).
 
 OPEN-ANGLES is the opening delimiter (e.g. \"«\" or \"<<\")."
-  (with-syntax-table perl6-bracket-syntax-table
+  (with-syntax-table raku-bracket-syntax-table
     (let* ((angle-length (length open-angles))
            (open-angle (string-to-char open-angles))
            (close-angle (matching-paren open-angle))
@@ -397,62 +397,62 @@ OPEN-ANGLES is the opening delimiter (e.g. \"«\" or 
\"<<\")."
                                                      (0+ space) (opt "\)") (0+ 
space) ,open-angle)) line-beg)))
           (put-text-property quote-beg (1+ quote-beg)
                              'syntax-table (string-to-syntax "|"))
-          (perl6-forward-brackets open-angle close-angle angle-length)
+          (raku-forward-brackets open-angle close-angle angle-length)
           (let ((quote-end (- (point) 1)))
             (put-text-property quote-beg quote-end 'syntax-multiline t)
             (put-text-property quote-end (1+ quote-end)
                                'syntax-table (string-to-syntax "|")))))))
 
-(defun perl6-syntax-propertize-backslash ()
-  (when (eq (perl6-syntax-context) nil)
+(defun raku-syntax-propertize-backslash ()
+  (when (eq (raku-syntax-context) nil)
     (put-text-property (match-beginning 0) (match-end 0)
                        'syntax-table (string-to-syntax "."))))
 
-(defun perl6-add-font-lock-hint (property &optional group)
+(defun raku-add-font-lock-hint (property &optional group)
   (let ((beg (match-beginning (or group 1)))
-        (context (perl6-syntax-context)))
+        (context (raku-syntax-context)))
     (put-text-property beg (1+ beg) property
                        (cons context (match-data)))))
 
-(defun perl6-syntax-propertize (start end)
+(defun raku-syntax-propertize (start end)
   "Add context-specific syntax properties to code.
 
 Takes arguments START and END which delimit the region to propertize."
   (let ((case-fold-search nil))
     (goto-char start)
-    (remove-text-properties start end '(perl6-metaoperator))
+    (remove-text-properties start end '(raku-metaoperator))
     (funcall
      (syntax-propertize-rules
       ;; [-'] between identifiers are symbol chars
       ((rx (regex "[_[:alnum:]]") (group (any "-'")) (regex "[_[:alpha:]]"))
        (1 "_"))
       ;; same for "::" around identifiers
-      ((perl6-rx (or (and (opt identifier) (group "::") symbol-start)
+      ((raku-rx (or (and (opt identifier) (group "::") symbol-start)
                      (and identifier (group "::"))))
        (1 "_")
        (2 "_"))
       ;; comments
       ((rx "#")
-       (0 (ignore (perl6-syntax-propertize-comment end))))
+       (0 (ignore (raku-syntax-propertize-comment end))))
       ;; postfix hyper operators
-      ((perl6-rx (or identifier "]" ")") (group (or "»" ">>")))
+      ((raku-rx (or identifier "]" ")") (group (or "»" ">>")))
        (0 nil))
       ;; other metaoperators like (-), R=>, [*], X~, »+«
-      ((perl6-rx (or set-operator rsxz-operator reduce-operator 
hyper-operator))
-       (0 (ignore (perl6-add-font-lock-hint 'perl6-metaoperator 0))))
+      ((raku-rx (or set-operator rsxz-operator reduce-operator hyper-operator))
+       (0 (ignore (raku-add-font-lock-hint 'raku-metaoperator 0))))
       ;; angle-bracketed quoting construct
       ((rx (or (1+ "<") (1+ "«")))
-       (0 (ignore (perl6-syntax-propertize-angles (match-string 0)))))
+       (0 (ignore (raku-syntax-propertize-angles (match-string 0)))))
       ;; backslashes outside strings/comments are punctuation, not escapes
       ((rx "\\")
-       (0 (ignore (perl6-syntax-propertize-backslash))))
+       (0 (ignore (raku-syntax-propertize-backslash))))
       ;; unicode string quotes
       ((rx (any "‘｢“"))
-       (0 (ignore (when (eq (perl6-syntax-context) nil)
+       (0 (ignore (when (eq (raku-syntax-context) nil)
                     (backward-char)
-                    (perl6-syntax-propertize-delimiters "|")))))
+                    (raku-syntax-propertize-delimiters "|")))))
       ;; sigils and twigils are prefix characters
-      ((perl6-rx variable)
+      ((raku-rx variable)
        (1 ". p")
        (2 ". p")
        ;; go back to the end of the twigils/sigils, so other syntax
@@ -460,15 +460,15 @@ Takes arguments START and END which delimit the region to 
propertize."
        (4 (ignore (goto-char (or (match-end 2) (match-end 1)))))))
      start end)))
 
-(defun perl6-font-lock-syntactic-face (state)
+(defun raku-font-lock-syntactic-face (state)
   "Specify font lock faces based on syntax table entries.
 
 Takes STATE, the parse state."
-  (pcase (perl6-syntax-context state)
-    (`string 'perl6-string)
-    (`comment 'perl6-comment)))
+  (pcase (raku-syntax-context state)
+    (`string 'raku-string)
+    (`comment 'raku-comment)))
 
-(defun perl6-search-when (regex condition limit)
+(defun raku-search-when (regex condition limit)
   "Search forward for REGEX if the match satisfies CONDITION.
 
 CONDITION should be a lambda that will be called after REGEX
@@ -496,20 +496,20 @@ LIMIT can be used to bound the search."
       (set-match-data new-match-data)
       (goto-char (match-end 0)))))
 
-(defun perl6-match-type-constraint (limit)
-  (perl6-search-when
-   (perl6-rx (or (group (symbol type-constraint))
+(defun raku-match-type-constraint (limit)
+  (raku-search-when
+   (raku-rx (or (group (symbol type-constraint))
                  (and (group (symbol "is"))
                       (1+ space)
                       (opt (group (symbol type-property))))))
    (lambda ()
      (goto-char (match-beginning 0))
-     (and (eq (perl6-syntax-context) nil)
+     (and (eq (raku-syntax-context) nil)
           (not (looking-back (rx (or (char ".^")
                                      (and line-start (0+ space))))))))
    limit))
 
-(defun perl6-match-property (property context limit)
+(defun raku-match-property (property context limit)
   (when (symbolp context)
     (setq context (list context)))
   (let ((pos (next-single-char-property-change (point) property nil limit)))
@@ -523,138 +523,138 @@ LIMIT can be used to bound the search."
         (let ((value (get-text-property pos-with-match-data property)))
           (if (and value (memq (car value) context))
               (progn (set-match-data (cdr value)) t)
-            (perl6-match-property property context limit)))))))
+            (raku-match-property property context limit)))))))
 
-(defun perl6-match-metaoperator (limit)
-  (perl6-match-property 'perl6-metaoperator nil limit))
+(defun raku-match-metaoperator (limit)
+  (raku-match-property 'raku-metaoperator nil limit))
 
-(defun perl6-match-string-delimiter (limit)
-  (perl6-search-when
-   (perl6-rx (or (syntax string-quote) (syntax string-delimiter)))
-   (lambda () (not (eq (perl6-syntax-context) `comment)))
+(defun raku-match-string-delimiter (limit)
+  (raku-search-when
+   (raku-rx (or (syntax string-quote) (syntax string-delimiter)))
+   (lambda () (not (eq (raku-syntax-context) `comment)))
    limit))
 
-(defconst perl6-font-lock-keywords
+(defconst raku-font-lock-keywords
   `(
     ;; (-) R=> [*] X~ »+«
-    (perl6-match-metaoperator 0 'perl6-operator)
+    (raku-match-metaoperator 0 'raku-operator)
     ;; placeholder sigils
-    (,(perl6-rx (group (any "@$%&"))
+    (,(raku-rx (group (any "@$%&"))
                 (or
                  "<"
                  (and (0+ space)
                       (or (any ",\)\}") (symbol "where")))))
-     1 'perl6-sigil)
+     1 'raku-sigil)
     ;; $foo @Bla::Hlagh $.bar $?CLASS
-    (,(perl6-rx variable)
-     (1 'perl6-sigil)
-     (2 'perl6-twigil)
-     (3 'perl6-var-package)
-     (4 'perl6-var-name))
+    (,(raku-rx variable)
+     (1 'raku-sigil)
+     (2 'raku-twigil)
+     (3 'raku-var-package)
+     (4 'raku-var-name))
     ;; v6.0.0
-    (,(perl6-rx symbol-start version) 0 'perl6-version)
+    (,(raku-rx symbol-start version) 0 'raku-version)
     ;; e.g. $foo is cached
-    (perl6-match-type-constraint
-     (1 'perl6-type-constraint nil t)
-     (2 'perl6-type-constraint nil t)
-     (3 'perl6-type-property nil t))
+    (raku-match-type-constraint
+     (1 'raku-type-constraint nil t)
+     (2 'raku-type-constraint nil t)
+     (3 'raku-type-property nil t))
     ;; method calls like $foo.bar or $hlagh.^methods
-    (,(perl6-rx (group (any ".^?")) (group identifier symbol-end))
-     (1 'perl6-operator)
-     (2 'perl6-identifier))
+    (,(raku-rx (group (any ".^?")) (group identifier symbol-end))
+     (1 'raku-operator)
+     (2 'raku-identifier))
     ;; autoquoting fat arrow, foo => $bar
-    (,(perl6-rx (group (symbol identifier)) (1+ space) (group "=>"))
-     (1 'perl6-string)
-     (2 'perl6-operator))
+    (,(raku-rx (group (symbol identifier)) (1+ space) (group "=>"))
+     (1 'raku-string)
+     (2 'raku-operator))
     ;; "proto foo", "proto sub foo", etc
-    (,(perl6-rx (group (symbol pre-declare))
+    (,(raku-rx (group (symbol pre-declare))
                 (opt (1+ space) (group (symbol declare)))
                 (opt (1+ space) (group identifier)))
-     (1 'perl6-declare)
-     (2 'perl6-declare nil t)
-     (3 'perl6-identifier nil t))
+     (1 'raku-declare)
+     (2 'raku-declare nil t)
+     (3 'raku-identifier nil t))
     ;; "sub foo"
-    (,(perl6-rx (group (symbol declare))
+    (,(raku-rx (group (symbol declare))
                 (opt (1+ space) (group identifier)))
-     (1 'perl6-declare)
-     (2 'perl6-identifier nil t))
+     (1 'raku-declare)
+     (2 'raku-identifier nil t))
     ;; high-level types (Scalar, Class, Str, etc)
-    (,(perl6-rx (group symbol-start high-type) "(") 1 'perl6-type)
+    (,(raku-rx (group symbol-start high-type) "(") 1 'raku-type)
     ;; anything preceding an open-paren is just an identifier
-    (,(perl6-rx (group symbol-start identifier) "(") 1 'perl6-identifier)
+    (,(raku-rx (group symbol-start identifier) "(") 1 'raku-identifier)
     ;; contextualizers
-    (,(perl6-rx
+    (,(raku-rx
        (or (and (group-n 1 (any "$@%&")) "(")
            (group-n 2 (symbol (or "item" "list" "hash")))))
-     (1 'perl6-operator nil t)
-     (2 'perl6-operator nil t))
+     (1 'raku-operator nil t)
+     (2 'raku-operator nil t))
     ;; low-level types (int, bool, complex, etc)
-    (,(perl6-rx (symbol (or low-type high-type))) 0 'perl6-type)
+    (,(raku-rx (symbol (or low-type high-type))) 0 'raku-type)
     ;; adverbs like :foo and :!bar
-    (,(perl6-rx (or bol (regex "[^:]")) (group ":" (opt "!")) (group (symbol 
identifier)))
-     (1 'perl6-operator)
-     (2 'perl6-string))
+    (,(raku-rx (or bol (regex "[^:]")) (group ":" (opt "!")) (group (symbol 
identifier)))
+     (1 'raku-operator)
+     (2 'raku-string))
     ;; div, and, eq...
-    (,(perl6-rx (symbol operator-word)) 0 'perl6-operator)
+    (,(raku-rx (symbol operator-word)) 0 'raku-operator)
     ;; BEGIN, CHECK, INIT...
-    (,(perl6-rx (symbol phaser)) 0 'perl6-phaser)
+    (,(raku-rx (symbol phaser)) 0 'raku-phaser)
     ;; die, fail, try...
-    (,(perl6-rx (symbol exception)) 0 'perl6-exception)
+    (,(raku-rx (symbol exception)) 0 'raku-exception)
     ;; let, my, our...
-    (,(perl6-rx (symbol scope)) 0 'perl6-scope)
+    (,(raku-rx (symbol scope)) 0 'raku-scope)
     ;; if, else, elsif...
-    (,(perl6-rx (symbol conditional)) 0 'perl6-conditional)
+    (,(raku-rx (symbol conditional)) 0 'raku-conditional)
     ;; use, require...
-    (,(perl6-rx (symbol include)) 0 'perl6-include)
+    (,(raku-rx (symbol include)) 0 'raku-include)
     ;; for, loop, repeat...
-    (,(perl6-rx (symbol loop)) 0 'perl6-loop)
+    (,(raku-rx (symbol loop)) 0 'raku-loop)
     ;; take, do, when...
-    (,(perl6-rx (symbol flow-control)) 0 'perl6-flow-control)
+    (,(raku-rx (symbol flow-control)) 0 'raku-flow-control)
     ;; oo, fatal...
-    (,(perl6-rx (symbol pragma)) 0 'perl6-pragma)
+    (,(raku-rx (symbol pragma)) 0 'raku-pragma)
     ;; special numbers
-    (,(perl6-rx (symbol (or "Inf" "NaN")))
-     0 'perl6-number)
+    (,(raku-rx (symbol (or "Inf" "NaN")))
+     0 'raku-number)
     ;; block label declarations
-    (,(perl6-rx line-start (0+ space) (group identifier ":") (or space 
line-end))
-     1 'perl6-label)
+    (,(raku-rx line-start (0+ space) (group identifier ":") (or space 
line-end))
+     1 'raku-label)
     ;; block label references
-    (,(perl6-rx (symbol (or "goto" "next" "last" "redo"))
+    (,(raku-rx (symbol (or "goto" "next" "last" "redo"))
                 (1+ space)
                 (group identifier))
-     1 'perl6-label)
+     1 'raku-label)
     ;; identifiers with colons
-    (,(perl6-rx
+    (,(raku-rx
        (or symbol-start
            (and "::" (group (opt (regex "[?*]")))))
        identifier
        (opt (0+ "::" identifier))
        (opt "::"))
-     (0 'perl6-identifier)
-     (1 'perl6-twigil t t))
+     (0 'raku-identifier)
+     (1 'raku-twigil t t))
     ;; numbers
-    (,(perl6-rx (or bol (regex "[^[:digit:]]")) number)
-     (1 'perl6-number)
-     (2 'perl6-number-addition nil t)
-     (3 'perl6-number nil t)
-     (4 'perl6-number-addition nil t))
+    (,(raku-rx (or bol (regex "[^[:digit:]]")) number)
+     (1 'raku-number)
+     (2 'raku-number-addition nil t)
+     (3 'raku-number nil t)
+     (4 'raku-number-addition nil t))
     ;; punctuation operators (+ - : / *, etc)
-    (,(perl6-rx operator-char) 0 'perl6-operator)
+    (,(raku-rx operator-char) 0 'raku-operator)
     ;; number with an explicit base (0b010101, 0x1ef1, etc)
-    (,(perl6-rx base-number)
-     (1 'perl6-number)
-     (2 'perl6-number-addition)
-     (3 'perl6-number))
+    (,(raku-rx base-number)
+     (1 'raku-number)
+     (2 'raku-number-addition)
+     (3 'raku-number))
     ;; highlight string delimiters as operators
-    (perl6-match-string-delimiter
-     0 'perl6-operator t))
-  "Font lock keywords for Perl 6.")
+    (raku-match-string-delimiter
+     0 'raku-operator t))
+  "Font lock keywords for Raku.")
 
-(provide 'perl6-font-lock)
+(provide 'raku-font-lock)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-font-lock.el ends here
+;;; raku-font-lock.el ends here
diff --git a/perl6-imenu.el b/raku-imenu.el
similarity index 75%
rename from perl6-imenu.el
rename to raku-imenu.el
index a48a729dbb..e3d3387b5c 100644
--- a/perl6-imenu.el
+++ b/raku-imenu.el
@@ -1,9 +1,9 @@
-;;; perl6-imenu.el --- Imenu support Perl 6 -*- lexical-binding: t; -*-
+;;; raku-imenu.el --- Imenu support Raku -*- lexical-binding: t; -*-
 
 ;; Imenu functions and variables are defined here.
 
 ;; Definition of "identifiers" (names) from
-;;   https://docs.perl6.org/language/syntax#Identifiers
+;;   https://docs.raku.org/language/syntax#Identifiers
 ;;
 ;; Identifiers are a grammatical building block that occur in several
 ;; places. An identifier is a primitive name, and must start with an
@@ -15,7 +15,7 @@
 ;; For NQP names, no embedded hyphens or single quotes are allowed.
 
 ;; Regex definitions:
-(defvar perl6-name-regex
+(defvar raku-name-regex
   (concat
    "[_[:alpha:]]"           ; mandatory leading character
    "\\(?:[-']?[[:alpha:]]"  ; rest of the name allowing embedded hyphens or 
single quotes or '::'
@@ -27,24 +27,24 @@
 (defvar nqp-name-regex
   (concat
    "[_[:alpha:]]"   ; mandatory leading character
-   "[_[:alnum:]]*"  ; rest of the name (stricter than Perl 6 name)
+   "[_[:alnum:]]*"  ; rest of the name (stricter than Raku name)
    ))
 
-(defvar perl6-vars-regex
+(defvar raku-vars-regex
   (concat
    "^\\s-*"                 ; leading ws allowed
    "\\(?:my\\|our\\|state\\)\\s-+"  ; scope of var, followed by mandatory ws
    "\\("                    ; start capture group 1 for the var name
    "\\(?:\\$\\|@\\|%\\)"    ; sigil for type of var
    "\\(?:"                  ; start shy group for choice of one type name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"                    ; end shy group
    "\\)"                    ; end of capture group 1
    ))
 
-(defvar perl6-subs-regex
+(defvar raku-subs-regex
   (concat
    "^\\s-*"                      ; leading ws allowed
    "\\(?:my\\s-+\\|our\\s-+\\)?" ; optional specific scope followed by at 
least one space
@@ -53,96 +53,96 @@
    
"\\(?:multi\\s-+sub\\|multi\\s-+method\\|sub\\|method\\|multi\\|proto\\)\\s-+"
    "\\!?"                        ; optional private marker
    "\\("                         ; start capture group 1 for the sub name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"                         ; end of capture group 1
    ))
 
-(defvar perl6-classes-regex
+(defvar raku-classes-regex
   (concat
    "^\\s-*"           ; leading ws allowed
                       ; must have one of the four type identifiers followed by 
at least one space:
    "class\\s-+"
    "\\("              ; start capture group 1 of the class name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"              ; end of capture group 1
    ))
 
-(defvar perl6-regexes-regex
+(defvar raku-regexes-regex
   (concat
    "^\\s-*"           ; leading ws allowed
                       ; must have an identifier followed by at least one space:
    "regex\\s-+"
    "\\("              ; start capture group 1 of the regex name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"              ; end of capture group 1
    ))
 
-(defvar perl6-tokens-regex
+(defvar raku-tokens-regex
   (concat
    "^\\s-*"           ; leading ws allowed
                       ; must have an identifier followed by at least one space:
    "token\\s-+"
    "\\("              ; start capture group 1 of the regex name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"              ; end of capture group 1
    ))
 
-(defvar perl6-rules-regex
+(defvar raku-rules-regex
   (concat
    "^\\s-*"           ; leading ws allowed
                       ; must have an identifier followed by at least one space:
    "rule\\s-+"
    "\\("              ; start capture group 1 of the regex name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"              ; end of capture group 1
    ))
 
-(defvar perl6-grammars-regex
+(defvar raku-grammars-regex
   (concat
    "^\\s-*"           ; leading ws allowed
                       ; must have an identifier followed by at least one space:
    "grammar\\s-+"
    "\\("              ; start capture group 1 of the regex name
-   perl6-name-regex
+   raku-name-regex
    "\\|"
    nqp-name-regex
    "\\)"              ; end of capture group 1
    ))
 
-(defvar perl6-imenu-generic-expression
+(defvar raku-imenu-generic-expression
   `(
     ;; the names are in reverse desired order since they are evaluated here 
last first
-    ("Rules" ,perl6-rules-regex 1)
-    ("Tokens" ,perl6-tokens-regex 1)
-    ("Regexes" ,perl6-regexes-regex 1)
-    ("Grammars" ,perl6-grammars-regex 1)
-    ("Classes" ,perl6-classes-regex 1)
-    ("Variables" ,perl6-vars-regex 1)
-    ("Subs/Methods" ,perl6-subs-regex 1)
+    ("Rules" ,raku-rules-regex 1)
+    ("Tokens" ,raku-tokens-regex 1)
+    ("Regexes" ,raku-regexes-regex 1)
+    ("Grammars" ,raku-grammars-regex 1)
+    ("Classes" ,raku-classes-regex 1)
+    ("Variables" ,raku-vars-regex 1)
+    ("Subs/Methods" ,raku-subs-regex 1)
     )
-      "Define interesting points in the Perl 6 buffer for `imenu'.
+      "Define interesting points in the Raku buffer for `imenu'.
 
-This is used to set `imenu-generic-expression' when Perl 6 mode is
-entered.  Subsequent changes to `perl6-imenu-generic-expression' will
-not affect existing Perl 6 buffers because imenu-generic-expression is
+This is used to set `imenu-generic-expression' when Raku mode is
+entered.  Subsequent changes to `raku-imenu-generic-expression' will
+not affect existing Raku buffers because imenu-generic-expression is
 a local variable.")
 
 ;;===========================
-(provide 'perl6-imenu)
+(provide 'raku-imenu)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-imenu.el ends here
+;;; raku-imenu.el ends here
diff --git a/perl6-indent.el b/raku-indent.el
similarity index 75%
rename from perl6-indent.el
rename to raku-indent.el
index b07acac279..517fceaa38 100644
--- a/perl6-indent.el
+++ b/raku-indent.el
@@ -1,4 +1,4 @@
-;;; perl6-indent.el --- Indentation support Perl 6 -*- lexical-binding: t; -*-
+;;; raku-indent.el --- Indentation support Raku -*- lexical-binding: t; -*-
 
 ;;; Commentary:
 
@@ -9,25 +9,25 @@
 
 (require 'smie)
 
-(defconst perl6-smie-grammar
+(defconst raku-smie-grammar
   (smie-prec2->grammar
    (smie-precs->prec2 '((assoc ";") (assoc ",") (left ":")))))
 
-(defcustom perl6-indent-offset 4
+(defcustom raku-indent-offset 4
   "Basic size of one indentation step."
   :type 'integer
-  :group 'perl6)
+  :group 'raku)
 
-(defun perl6-smie--not-interpolation-p ()
+(defun raku-smie--not-interpolation-p ()
   (save-excursion
     (forward-char -1)
     (or (zerop (skip-chars-backward "-[:alnum:]"))
         (not (looking-back "#{\\$" (- (point) 3))))))
 
-(defun perl6-smie--forward-token ()
+(defun raku-smie--forward-token ()
   (cond
    ((and (eq (char-before) ?\})
-           (perl6-smie--not-interpolation-p)
+           (raku-smie--not-interpolation-p)
            ;; FIXME: If the next char is not whitespace, what should we do?
            (or (memq (char-after) '(?\s ?\t ?\n))
                (looking-at comment-start-skip)))
@@ -39,20 +39,20 @@
     (forward-char 1) (match-string 0))
    (t (smie-default-forward-token))))
 
-(defun perl6-smie--backward-token ()
+(defun raku-smie--backward-token ()
   (let ((pos (point)))
     (forward-comment (- (point)))
     (cond
      ;; FIXME: If the next char is not whitespace, what should we do?
-     ((and (eq (char-before) ?\}) (perl6-smie--not-interpolation-p)
+     ((and (eq (char-before) ?\}) (raku-smie--not-interpolation-p)
            (> pos (point))) ";")
      ((memq (char-before) '(?\; ?\, ?\:))
       (forward-char -1) (string (char-after)))
      (t (smie-default-backward-token)))))
 
-(defun perl6-smie-rules (kind token)
+(defun raku-smie-rules (kind token)
   (pcase (cons kind token)
-    (`(:elem . basic) perl6-indent-offset)
+    (`(:elem . basic) raku-indent-offset)
     (`(:elem . arg) 0)
     (`(:list-intro . ,(or `";" `"")) t) ;"" stands for BOB (bug#15467).
     (`(:before . "{")
@@ -62,11 +62,11 @@
     (`(:before . ,(or "{" "("))
      (if (smie-rule-hanging-p) (smie-rule-parent 0)))))
 
-(provide 'perl6-indent)
+(provide 'raku-indent)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-indent.el ends here
+;;; raku-indent.el ends here
diff --git a/perl6-mode.el b/raku-mode.el
similarity index 51%
rename from perl6-mode.el
rename to raku-mode.el
index 6cbe1449ce..fdf49b6060 100644
--- a/perl6-mode.el
+++ b/raku-mode.el
@@ -1,4 +1,4 @@
-;;; perl6-mode.el --- Major mode for editing Perl 6 code -*- lexical-binding: 
t; -*-
+;;; raku-mode.el --- Major mode for editing Raku code -*- lexical-binding: t; 
-*-
 
 ;; Copyright (C) 2015  Hinrik Örn Sigurðsson <hinrik.sig@gmail.com>
 
@@ -25,7 +25,7 @@
 
 ;;; Commentary:
 
-;; GNU Emacs 24 major mode for editing Perl 6 code.
+;; GNU Emacs 24 major mode for editing Raku code.
 
 ;; Currently only provides very basic syntax highlighting.
 
@@ -33,44 +33,44 @@
 
 (declare-function pkg-info-version-info "pkg-info" (library))
 
-(defgroup perl6 nil
-  "Major mode for editing Perl 6 code."
-  :prefix "perl6-"
+(defgroup raku nil
+  "Major mode for editing Raku code."
+  :prefix "raku-"
   :group 'language)
 
-(require 'perl6-detect)
-(require 'perl6-font-lock)
-(require 'perl6-indent)
-(require 'perl6-imenu)
-(require 'perl6-repl)
+(require 'raku-detect)
+(require 'raku-font-lock)
+(require 'raku-indent)
+(require 'raku-imenu)
+(require 'raku-repl)
 
-(defvar perl6-mode-map
+(defvar raku-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-c C-c") 'perl6-send-line-to-repl)
-    (define-key map (kbd "C-c C-r") 'perl6-send-region-to-repl)
-    (define-key map (kbd "C-c C-h") 'perl6-send-buffer-to-repl)
+    (define-key map (kbd "C-c C-c") 'raku-send-line-to-repl)
+    (define-key map (kbd "C-c C-r") 'raku-send-region-to-repl)
+    (define-key map (kbd "C-c C-h") 'raku-send-buffer-to-repl)
     map)
-  "Keymap for `perl6-mode'.")
+  "Keymap for `raku-mode'.")
 
-(easy-menu-define perl6-mode-menu perl6-mode-map
-  "Menu for `perl6-mode'"
+(easy-menu-define raku-mode-menu raku-mode-map
+  "Menu for `raku-mode'"
   '("Raku"
-    ["Send line to repl" perl6-send-line-to-repl]
-    ["Send region to repl" perl6-send-region-to-repl]
-    ["Send buffer to repl" perl6-send-buffer-to-repl]))
+    ["Send line to repl" raku-send-line-to-repl]
+    ["Send region to repl" raku-send-region-to-repl]
+    ["Send buffer to repl" raku-send-buffer-to-repl]))
 
 ;;;###autoload
-(define-derived-mode perl6-mode prog-mode "Perl6"
-  "Major mode for editing Perl 6 code."
+(define-derived-mode raku-mode prog-mode "Raku"
+  "Major mode for editing Raku code."
   ;; Syntaxification and font locking
-  (setq-local syntax-propertize-function #'perl6-syntax-propertize)
+  (setq-local syntax-propertize-function #'raku-syntax-propertize)
   (add-hook 'syntax-propertize-extend-region-functions 
#'syntax-propertize-multiline nil 'local)
-  (setq-local font-lock-syntactic-face-function 
#'perl6-font-lock-syntactic-face)
-  (setq-local font-lock-defaults '(perl6-font-lock-keywords nil nil))
-  ;; Add imenu support for perl6-mode.  Note that imenu-generic-expression
+  (setq-local font-lock-syntactic-face-function 
#'raku-font-lock-syntactic-face)
+  (setq-local font-lock-defaults '(raku-font-lock-keywords nil nil))
+  ;; Add imenu support for raku-mode.  Note that imenu-generic-expression
   ;; is buffer-local, so we don't need a local-variable for it.
-  (add-hook 'perl6-mode-hook 'imenu-add-menubar-index)
-  (setq imenu-generic-expression perl6-imenu-generic-expression
+  (add-hook 'raku-mode-hook 'imenu-add-menubar-index)
+  (setq imenu-generic-expression raku-imenu-generic-expression
       imenu-case-fold-search nil)
   ;; Comments
   (setq-local comment-start "#")
@@ -78,23 +78,23 @@
   (setq-local comment-use-syntax t)
   (setq-local comment-end "")
    ;; REPL
-  (setq comint-prompt-regexp perl6-prompt-regexp)
+  (setq comint-prompt-regexp raku-prompt-regexp)
   (setq comint-prompt-read-only t)
-  (set (make-local-variable 'paragraph-start) perl6-prompt-regexp)
+  (set (make-local-variable 'paragraph-start) raku-prompt-regexp)
   ;; Indentation (see SMIE in the Emacs manual)
   ;; TODO add rules for HEREDOC indentation
-  (smie-setup perl6-smie-grammar #'perl6-smie-rules
-              :forward-token #'perl6-smie--forward-token
-              :backward-token #'perl6-smie--backward-token)
-  (use-local-map perl6-mode-map))
+  (smie-setup raku-smie-grammar #'raku-smie-rules
+              :forward-token #'raku-smie--forward-token
+              :backward-token #'raku-smie--backward-token)
+  (use-local-map raku-mode-map))
 
 
 
-(provide 'perl6-mode)
+(provide 'raku-mode)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-mode.el ends here
+;;; raku-mode.el ends here
diff --git a/perl6-repl.el b/raku-repl.el
similarity index 50%
rename from perl6-repl.el
rename to raku-repl.el
index 0dab25cdf6..5ea7fcc4cf 100644
--- a/perl6-repl.el
+++ b/raku-repl.el
@@ -1,4 +1,4 @@
-;;; perl6-repl -- Repl for support Raku
+;;; raku-repl -- Repl for support Raku
 
 ;;; Commentary:
 ;; Basic repl support for Raku
@@ -6,68 +6,68 @@
 ;;; Code:
 (require 'comint)
 
-(defcustom perl6-exec-path "raku"
+(defcustom raku-exec-path "raku"
   "Raku executable path."
   :type 'string
-  :group 'perl6)
+  :group 'raku)
 
-(defcustom perl6-exec-arguments ""
+(defcustom raku-exec-arguments ""
   "Raku command line arguments."
   :type 'string
-  :group 'perl6)
+  :group 'raku)
 
-(defvar perl6-prompt-regexp "^> "
-  "Prompt for `run-perl6'.")
+(defvar raku-prompt-regexp "^> "
+  "Prompt for `run-raku'.")
 
-(defvar perl6-buffer-name "Raku REPL"
-  "Buffer name for `run-perl6.")
+(defvar raku-buffer-name "Raku REPL"
+  "Buffer name for `run-raku.")
 
-(defun run-perl6 ()
+(defun run-raku ()
   "Run an inferior instance of `raku' inside Emacs."
   (interactive)
-  (let* ((perl6-program perl6-exec-path)
-         (check-proc (comint-check-proc perl6-buffer-name))
+  (let* ((raku-program raku-exec-path)
+         (check-proc (comint-check-proc raku-buffer-name))
          (buffer (apply 'make-comint-in-buffer
-                        perl6-buffer-name
+                        raku-buffer-name
                         check-proc
-                        perl6-exec-path
+                        raku-exec-path
                         '()
-                        (split-string perl6-exec-arguments))))
+                        (split-string raku-exec-arguments))))
     (display-buffer buffer)))
 
-(defun perl6-comint-get-process ()
+(defun raku-comint-get-process ()
   "Raku process name."
-  (get-process perl6-buffer-name))
+  (get-process raku-buffer-name))
 
-(defun perl6-send-string-to-repl (str)
+(defun raku-send-string-to-repl (str)
   "Send STR to the repl."
-  (comint-send-string (perl6-comint-get-process)
+  (comint-send-string (raku-comint-get-process)
                       (concat str "\n")))
 
-(defun perl6-send-line-to-repl ()
+(defun raku-send-line-to-repl ()
   "Send a line to the repl."
   (interactive)
-  (run-perl6)
+  (run-raku)
   (let ((str (buffer-substring-no-properties (line-beginning-position) 
(line-end-position))))
-    (perl6-send-string-to-repl str)))
+    (raku-send-string-to-repl str)))
 
-(defun perl6-send-region-to-repl ()
+(defun raku-send-region-to-repl ()
   "Send a region to the repl."
   (interactive)
-  (run-perl6)
+  (run-raku)
   (if (region-active-p)
       (let ((buf (buffer-substring-no-properties (region-beginning)
                                                  (region-end))))
-        (perl6-send-string-to-repl buf))
+        (raku-send-string-to-repl buf))
     (message "No region selected")))
 
-(defun perl6-send-buffer-to-repl ()
+(defun raku-send-buffer-to-repl ()
   "Send a buffer to the repl."
   (interactive)
-  (run-perl6)
+  (run-raku)
   (let ((buf (buffer-substring-no-properties (point-min)
                                              (point-max))))
-    (perl6-send-string-to-repl buf)))
+    (raku-send-string-to-repl buf)))
 
-(provide 'perl6-repl)
-;;; perl6-repl.el ends here
+(provide 'raku-repl)
+;;; raku-repl.el ends here
diff --git a/perl6-unicode-menu.el b/raku-unicode-menu.el
similarity index 92%
rename from perl6-unicode-menu.el
rename to raku-unicode-menu.el
index b4a87e71d3..8be26701bc 100644
--- a/perl6-unicode-menu.el
+++ b/raku-unicode-menu.el
@@ -20,11 +20,11 @@
 
 
 ;;===========================
-(provide 'perl6-unicode-menu)
+(provide 'raku-unicode-menu)
 
 ;; Local Variables:
 ;; coding: utf-8
 ;; indent-tabs-mode: nil
 ;; End:
 
-;;; perl6-imenu.el ends here
+;;; raku-imenu.el ends here
diff --git a/test/perl6-mode-test.el b/test/perl6-mode-test.el
deleted file mode 100644
index c3b624bc83..0000000000
--- a/test/perl6-mode-test.el
+++ /dev/null
@@ -1,122 +0,0 @@
-;;; perl6-mode-test.el --- Perl 6 Mode: Unit test suite  -*- lexical-binding: 
t; -*-
-
-;;; Commentary:
-
-;; The unit test suite of Perl 6 Mode.
-
-;;; Code:
-
-(require 'perl6-mode)
-(require 'ert)
-
-
-;;;; Utilities
-
-(defmacro perl6-test-with-temp-buffer (content &rest body)
-  "In the temporary buffer CONTENT, evaluate BODY."
-  (declare (debug t)
-           (indent 1))
-  `(with-temp-buffer
-     (insert ,content)
-     (perl6-mode)
-     (font-lock-fontify-buffer)
-     (goto-char (point-min))
-     ,@body))
-
-(defun perl6-test-face-at (pos &optional content)
-  "Get the face at POS in CONTENT.
-
-If CONTENT is not given, return the face at POS in the current
-buffer."
-  (if content
-      (perl6-test-with-temp-buffer content
-        (get-text-property pos 'face))
-    (get-text-property pos 'face)))
-
-(defconst perl6-test-syntax-classes
-  [whitespace punctuation word symbol open-paren close-paren expression-prefix
-              string-quote paired-delim escape character-quote comment-start
-              comment-end inherit generic-comment generic-string]
-  "Readable symbols for syntax classes.
-
-Each symbol in this vector corresponding to the syntax code of
-its index.")
-
-(defun perl6-test-syntax-at (pos)
-  "Get the syntax at POS.
-
-Get the syntax class symbol at POS, or nil if there is no syntax a
-POS."
-  (let ((code (syntax-class (syntax-after pos))))
-    (aref perl6-test-syntax-classes code)))
-
-
-;;;; Font locking
-(ert-deftest perl6-syntax-propertize/colons-identifier ()
-  :tags '(syntax-table syntax-properties)
-  (perl6-test-with-temp-buffer "class Foo::Bar"
-                                (should (eq (perl6-test-syntax-at 10) 'symbol))
-                                (should (eq (perl6-test-syntax-at 11) 
'symbol))))
-
-(ert-deftest perl6-syntax-propertize/angles ()
-  :tags '(syntax-table syntax-properties)
-  (perl6-test-with-temp-buffer "my @foo = <bar>; for @foo <-> $bar {}"
-                                (should (eq (perl6-test-syntax-at 11) 
'generic-string))
-                                (should (eq (perl6-test-syntax-at 15) 
'generic-string))
-                                (should (eq (perl6-test-syntax-at 27) 
'punctuation))
-                                (should (eq (perl6-test-syntax-at 29) 
'punctuation))))
-
-(ert-deftest perl6-syntax-propertize/dq-words ()
-  :tags '(syntax-table syntax-properties)
-  (perl6-test-with-temp-buffer "foo «bar1 bar2» bla <<baz1 baz2>> quux"
-                               (should (eq (perl6-test-syntax-at 1) 'word))
-                               (should (eq (perl6-test-syntax-at 5) 
'generic-string))
-                               (should (eq (perl6-test-syntax-at 15) 
'generic-string))
-                               (should (eq (perl6-test-syntax-at 21) 
'generic-string))
-                               (should (eq (perl6-test-syntax-at 22) 
'punctuation))
-                               (should (eq (perl6-test-syntax-at 32) 
'punctuation))
-                               (should (eq (perl6-test-syntax-at 33) 
'generic-string))))
-
-(ert-deftest perl6-mode-syntax-table/fontify-dq-string ()
-  :tags '(fontification syntax-table)
-  (should (eq (perl6-test-face-at 9 "$foo = \"bar\"") 'perl6-string)))
-
-(ert-deftest perl6-mode-syntax-table/fontify-set-operator ()
-  :tags '(fontification syntax-table)
-  (should (eq (perl6-test-face-at 6 "$mh (<+) $m") 'perl6-operator)))
-
-(ert-deftest perl6-mode-syntax-table/fontify-sq-string ()
-  :tags '(fontification syntax-table)
-  (should (eq (perl6-test-face-at 9 "$foo = 'bar'") 'perl6-string)))
-
-(ert-deftest perl6-mode-syntax-table/fontify-line-comment ()
-  :tags '(fontification syntax-table)
-  (perl6-test-with-temp-buffer "# class
-bar #`<foo> baz"
-    (should (eq (perl6-test-face-at 3) 'perl6-comment))
-    (should (eq (perl6-test-face-at 7) 'perl6-comment))
-    (should (eq (perl6-test-face-at 8) 'perl6-comment))
-    (should (eq (perl6-test-face-at 9) 'perl6-identifier))
-    (should (eq (perl6-test-face-at 16) 'perl6-comment))))
-
-(ert-deftest perl6-font-lock-keywords/phaser ()
-  :tags '(fontification font-lock-keywords)
-  (perl6-test-with-temp-buffer "BEGIN {"
-    (should (eq (perl6-test-face-at 1) 'perl6-phaser))))
-
-(ert-deftest perl5-font-lock-keywords/variable ()
-  :tags '(fontification syntax-table)
-  (perl6-test-with-temp-buffer "$::foo @!bar"
-    (should (eq (perl6-test-face-at 3) 'perl6-var-package))
-    (should (eq (perl6-test-face-at 4) 'perl6-var-name))
-    (should (eq (perl6-test-face-at 8) 'perl6-sigil))
-    (should (eq (perl6-test-face-at 9) 'perl6-twigil))
-    (should (eq (perl6-test-face-at 10) 'perl6-var-name))))
-
-(provide 'perl6-mode-test)
-
-;; Local Variables:
-;; indent-tabs-mode: nil
-;; End:
-
-;;; perl6-mode-test.el ends here
diff --git a/test/raku-mode-test.el b/test/raku-mode-test.el
new file mode 100644
index 0000000000..a503a1956d
--- /dev/null
+++ b/test/raku-mode-test.el
@@ -0,0 +1,122 @@
+;;; raku-mode-test.el --- Raku Mode: Unit test suite  -*- lexical-binding: t; 
-*-
+
+;;; Commentary:
+
+;; The unit test suite of Raku Mode.
+
+;;; Code:
+
+(require 'raku-mode)
+(require 'ert)
+
+
+;;;; Utilities
+
+(defmacro raku-test-with-temp-buffer (content &rest body)
+  "In the temporary buffer CONTENT, evaluate BODY."
+  (declare (debug t)
+           (indent 1))
+  `(with-temp-buffer
+     (insert ,content)
+     (raku-mode)
+     (font-lock-fontify-buffer)
+     (goto-char (point-min))
+     ,@body))
+
+(defun raku-test-face-at (pos &optional content)
+  "Get the face at POS in CONTENT.
+
+If CONTENT is not given, return the face at POS in the current
+buffer."
+  (if content
+      (raku-test-with-temp-buffer content
+        (get-text-property pos 'face))
+    (get-text-property pos 'face)))
+
+(defconst raku-test-syntax-classes
+  [whitespace punctuation word symbol open-paren close-paren expression-prefix
+              string-quote paired-delim escape character-quote comment-start
+              comment-end inherit generic-comment generic-string]
+  "Readable symbols for syntax classes.
+
+Each symbol in this vector corresponding to the syntax code of
+its index.")
+
+(defun raku-test-syntax-at (pos)
+  "Get the syntax at POS.
+
+Get the syntax class symbol at POS, or nil if there is no syntax a
+POS."
+  (let ((code (syntax-class (syntax-after pos))))
+    (aref raku-test-syntax-classes code)))
+
+
+;;;; Font locking
+(ert-deftest raku-syntax-propertize/colons-identifier ()
+  :tags '(syntax-table syntax-properties)
+  (raku-test-with-temp-buffer "class Foo::Bar"
+                                (should (eq (raku-test-syntax-at 10) 'symbol))
+                                (should (eq (raku-test-syntax-at 11) 
'symbol))))
+
+(ert-deftest raku-syntax-propertize/angles ()
+  :tags '(syntax-table syntax-properties)
+  (raku-test-with-temp-buffer "my @foo = <bar>; for @foo <-> $bar {}"
+                                (should (eq (raku-test-syntax-at 11) 
'generic-string))
+                                (should (eq (raku-test-syntax-at 15) 
'generic-string))
+                                (should (eq (raku-test-syntax-at 27) 
'punctuation))
+                                (should (eq (raku-test-syntax-at 29) 
'punctuation))))
+
+(ert-deftest raku-syntax-propertize/dq-words ()
+  :tags '(syntax-table syntax-properties)
+  (raku-test-with-temp-buffer "foo «bar1 bar2» bla <<baz1 baz2>> quux"
+                               (should (eq (raku-test-syntax-at 1) 'word))
+                               (should (eq (raku-test-syntax-at 5) 
'generic-string))
+                               (should (eq (raku-test-syntax-at 15) 
'generic-string))
+                               (should (eq (raku-test-syntax-at 21) 
'generic-string))
+                               (should (eq (raku-test-syntax-at 22) 
'punctuation))
+                               (should (eq (raku-test-syntax-at 32) 
'punctuation))
+                               (should (eq (raku-test-syntax-at 33) 
'generic-string))))
+
+(ert-deftest raku-mode-syntax-table/fontify-dq-string ()
+  :tags '(fontification syntax-table)
+  (should (eq (raku-test-face-at 9 "$foo = \"bar\"") 'raku-string)))
+
+(ert-deftest raku-mode-syntax-table/fontify-set-operator ()
+  :tags '(fontification syntax-table)
+  (should (eq (raku-test-face-at 6 "$mh (<+) $m") 'raku-operator)))
+
+(ert-deftest raku-mode-syntax-table/fontify-sq-string ()
+  :tags '(fontification syntax-table)
+  (should (eq (raku-test-face-at 9 "$foo = 'bar'") 'raku-string)))
+
+(ert-deftest raku-mode-syntax-table/fontify-line-comment ()
+  :tags '(fontification syntax-table)
+  (raku-test-with-temp-buffer "# class
+bar #`<foo> baz"
+    (should (eq (raku-test-face-at 3) 'raku-comment))
+    (should (eq (raku-test-face-at 7) 'raku-comment))
+    (should (eq (raku-test-face-at 8) 'raku-comment))
+    (should (eq (raku-test-face-at 9) 'raku-identifier))
+    (should (eq (raku-test-face-at 16) 'raku-comment))))
+
+(ert-deftest raku-font-lock-keywords/phaser ()
+  :tags '(fontification font-lock-keywords)
+  (raku-test-with-temp-buffer "BEGIN {"
+    (should (eq (raku-test-face-at 1) 'raku-phaser))))
+
+(ert-deftest perl5-font-lock-keywords/variable ()
+  :tags '(fontification syntax-table)
+  (raku-test-with-temp-buffer "$::foo @!bar"
+    (should (eq (raku-test-face-at 3) 'raku-var-package))
+    (should (eq (raku-test-face-at 4) 'raku-var-name))
+    (should (eq (raku-test-face-at 8) 'raku-sigil))
+    (should (eq (raku-test-face-at 9) 'raku-twigil))
+    (should (eq (raku-test-face-at 10) 'raku-var-name))))
+
+(provide 'raku-mode-test)
+
+;; Local Variables:
+;; indent-tabs-mode: nil
+;; End:
+
+;;; raku-mode-test.el ends here
diff --git a/test/test-helper.el b/test/test-helper.el
index bddd17f9a9..be45a29abc 100644
--- a/test/test-helper.el
+++ b/test/test-helper.el
@@ -1,4 +1,4 @@
-;;; test-helper.el --- Perl 6 Mode: Non-interactive unit-test setup  -*- 
lexical-binding: t; -*-
+;;; test-helper.el --- Raku Mode: Non-interactive unit-test setup  -*- 
lexical-binding: t; -*-
 
 ;;; Commentary:
 
@@ -14,7 +14,7 @@
        (load-prefer-newer t))
   ;; Load the file under test
   (add-to-list 'load-path source-directory)
-  (load (expand-file-name "perl6-mode")))
+  (load (expand-file-name "raku-mode")))
 
 ;; Local Variables:
 ;; indent-tabs-mode: nil
diff --git a/test/test-imenu.nqp b/test/test-imenu.nqp
index 307bd422b6..7f2b5d5b56 100644
--- a/test/test-imenu.nqp
+++ b/test/test-imenu.nqp
@@ -1,8 +1,8 @@
 # file: test-imenu.p6
 
-# Perl 6 syntax file for testing perl6-mode with imenu support, which is 
located at:
+# Raku syntax file for testing raku-mode with imenu support, which is located 
at:
 #
-#   https://github.com/tbrowder/perl6-mode [branch: "my-branch"]
+#   https://github.com/tbrowder/raku-mode [branch: "my-branch"]
 
 my $a;
 my @b;
diff --git a/test/test-imenu.p6 b/test/test-imenu.p6
index 6268250e4d..8b5fcb4820 100644
--- a/test/test-imenu.p6
+++ b/test/test-imenu.p6
@@ -1,9 +1,9 @@
 # file: test-imenu.p6
 
-# Perl 6 syntax file for testing perl6-mode with imenu support, which
+# Raku syntax file for testing raku-mode with imenu support, which
 # is located at:
 #
-#   https://github.com/tbrowder/perl6-mode [branch: "my-branch"]
+#   https://github.com/tbrowder/raku-mode [branch: "my-branch"]
 
 my $a;
 my @b;
diff --git a/test/test-smie.p6 b/test/test-smie.p6
index d6cdbd1c3f..f035ebee52 100644
--- a/test/test-smie.p6
+++ b/test/test-smie.p6
@@ -1,4 +1,4 @@
-#!/usr/bin/env perl6
+#!/usr/bin/env raku
 qq:to/HERE/;
     This is text that should not
   have its indention changed