Do token number asserts outside Command (replace .tokens with .name and .args)

app/main.go

 
 type Command struct {
 	command_type CommandType
-	tokens       []string
+	args         []string
 	exec_path    string
+	name         string
 }
 
 func makeCommandNone() Command {
 	return Command{
 		command_type: CommandTypeNone,
-		tokens:       nil,
+		args:         nil,
 		exec_path:    "",
+		name:         "",
 	}
 }
 
 	case CommandTypeExternal:
 		panic("invalid usage")
 	default:
+		if len(tokens) < 1 {
+			panic("assertion failed: token list must not be empty")
+		}
 		return Command{
 			command_type: command_type,
-			tokens:       tokens,
+			name:         tokens[0],
+			args:         tokens[1:],
 		}
 	}
 }
 
 func makeCommandExternal(tokens []string, exec_path string) Command {
+	if len(tokens) < 1 {
+		panic("assertion failed: token list must not be empty")
+	}
 	return Command{
 		command_type: CommandTypeExternal,
-		tokens:       tokens,
+		name:         tokens[0],
+		args:         tokens[1:],
 		exec_path:    exec_path,
 	}
 }
 		os.Exit(0)
 
 	case CommandTypeBuiltinEcho:
-		fmt.Fprintln(ctx.stdout, strings.Join(command.tokens[1:], " "))
+		fmt.Fprintln(ctx.stdout, strings.Join(command.args, " "))
 		return 0
 
 	case CommandTypeBuiltinPwd:
-		if len(command.tokens) != 1 {
+		if len(command.args) != 0 {
 			fmt.Fprintln(ctx.stderr, "usage: pwd")
 			return 2
 		}
 		return 0
 
 	case CommandTypeBuiltinType:
-		if len(command.tokens) != 2 {
+		if len(command.args) != 1 {
 			fmt.Fprintln(ctx.stderr, "usage: type COMMAND")
 			return 2
 		}
-		parsed, err := parseCommand(command.tokens[1])
+		parsed, err := parseCommand(command.args[0])
 		if err != nil {
 			fmt.Fprintln(ctx.stderr, err)
 			return 0
 		case CommandTypeNone:
 			panic("impossible parseCommand() result")
 		case CommandTypeExternal:
-			fmt.Fprintf(ctx.stdout, "%s is %s\n", parsed.tokens[0], parsed.exec_path)
+			fmt.Fprintf(ctx.stdout, "%s is %s\n", parsed.name, parsed.exec_path)
 		default:
-			fmt.Fprintf(ctx.stdout, "%s is a shell builtin\n", parsed.tokens[0])
+			fmt.Fprintf(ctx.stdout, "%s is a shell builtin\n", parsed.name)
 		}
 		return 0
 
 	case CommandTypeExternal:
-		cmd := exec.Command(command.exec_path, command.tokens[1:]...)
-		cmd.Args = command.tokens
+		cmd := exec.Command(command.exec_path, command.args...)
+		cmd.Args[0] = command.name
 		cmd.Stdout = ctx.stdout
 		cmd.Stderr = ctx.stderr
 		cmd.Stdin = ctx.stdin