diff --git a/misc/emacs/gn-mode.el b/misc/emacs/gn-mode.el
index f57d28f..bd9e150 100644
--- a/misc/emacs/gn-mode.el
+++ b/misc/emacs/gn-mode.el
@@ -71,8 +71,9 @@
     "forward_variables_from" "get_label_info" "get_path_info"
     "get_target_outputs" "getenv" "import" "not_needed" "print"
     "process_file_template" "read_file" "rebase_path" "set_default_toolchain"
-    "set_defaults" "set_sources_assignment_filter" "split_list" "template"
-    "tool" "toolchain" "propagates_configs" "write_file"))
+    "set_defaults" "set_sources_assignment_filter" "split_list" "string_join"
+    "string_split" "template" "tool" "toolchain" "propagates_configs"
+    "write_file"))
 
 (defvar gn-font-lock-predefined-var-keywords
   '("current_cpu" "current_os" "current_toolchain" "default_toolchain"
diff --git a/misc/tm/GN.tmLanguage b/misc/tm/GN.tmLanguage
index 5cccf4b..775b95e 100644
--- a/misc/tm/GN.tmLanguage
+++ b/misc/tm/GN.tmLanguage
@@ -73,7 +73,7 @@
       <key>comment</key>
       <string>functions</string>
       <key>match</key>
-      <string>\b(?:assert|config|declare_args|defined|exec_script|foreach|get_label_info|get_path_info|get_target_outputs|getenv|import|print|process_file_template|read_file|rebase_path|set_default_toolchain|set_defaults|set_sources_assignment_filter|template|tool|toolchain|toolchain_args|propagates_configs|write_file)\b</string>
+      <string>\b(?:assert|config|declare_args|defined|exec_script|foreach|get_label_info|get_path_info|get_target_outputs|getenv|import|print|process_file_template|read_file|rebase_path|set_default_toolchain|set_defaults|set_sources_assignment_filter|split_list|string_join|string_split|template|tool|toolchain|toolchain_args|propagates_configs|write_file)\b</string>
       <key>name</key>
       <string>entity.name.function.gn</string>
     </dict>
diff --git a/misc/vim/syntax/gn.vim b/misc/vim/syntax/gn.vim
index 9d5b060..6fe6d0b 100644
--- a/misc/vim/syntax/gn.vim
+++ b/misc/vim/syntax/gn.vim
@@ -34,10 +34,11 @@
 syn keyword     gnFunctions assert config declare_args defined exec_script
 syn keyword     gnFunctions foreach get_label_info get_path_info
 syn keyword     gnFunctions get_target_outputs getenv import print
-syn keyword     gnFunctions process_file_template read_file rebase_path
-syn keyword     gnFunctions set_default_toolchain set_defaults
-syn keyword     gnFunctions set_sources_assignment_filter template tool
-syn keyword     gnFunctions toolchain toolchain_args propagates_configs write_file
+syn keyword     gnFunctions process_file_template propagates_configs read_file
+syn keyword     gnFunctions rebase_path set_default_toolchain set_defaults
+syn keyword     gnFunctions set_sources_assignment_filter split_list string_join
+syn keyword     gnFunctions string_split template tool toolchain toolchain_args
+syn keyword     gnFunctions write_file
 hi def link     gnFunctions         Macro
 
 " Variables
