                        (setq inside-indenting-paren t)))))
                 (setq first nil))))
 
-          (setq current-line-closes-scope
-                (case (char-after)
-                  ((?\} ?\)) t)
-                  (t nil)))
-
           ;; case, default, and labels are outdented 1 level
           (when (looking-at "\\<case\\>\\|\\<default\\>\\|\\w+\\s *:\\(\\S.\\|$\\)")
-            (decf indent tab-width)
-            ;; Lines with case, default, etc. also "close" the previous line's 
-            ;; scope, even when there is no semicolon. Don't treat them as
-            ;; continuation lines.
-            (setq current-line-closes-scope t))
+            (decf indent tab-width))
 
           ;; Continuation lines are indented 1 level
           (forward-comment (- (buffer-size)))
           (when (case (char-before)
-                  ((?\{ ?\} ?\; ?:)
-                   ;; Not a continuation line
+                  ((nil ?\{ ?:)
+                   ;; At the beginning of a block or the statement
+                   ;; following a label.
                    nil)
                   ((?\()
-                   ;; Usually a continuation line, unless this paren
-                   ;; counted towards our indentation already
+                   ;; Usually a continuation line in an expression,
+                   ;; unless this paren is part of a factored
+                   ;; declaration.
                    (not inside-indenting-paren))
                   ((?,)
                    ;; Could be inside a literal.  We're a little

    st)
  "Syntax table for Go mode.")

(defvar go-mode-font-lock-keywords
  (let ((keywords '("import" "package"
                    "var" "const" "type" "func"
                    "struct" "interface"
                    "chan" "map"
                    "if" "else" "for" "switch" "select"
                    "range" "case" "default"
                    "return" "continue" "break" "fallthrough" "goto"
                    "go" "defer"))
        (builtins '("cap" "close" "closed" "len" "make" "new"
                    "panic" "panicln" "print" "println"))
        (constants '("nil" "true" "false" "iota"))
        (type-name "\\s *\\(?:[*(]\\s *\\)*\\(?:\\w+\\s *\\.\\s *\\)?\\(\\w+\\)")
        )
    `((,(regexp-opt keywords 'words) . font-lock-keyword-face)
      (,(regexp-opt builtins 'words) . font-lock-builtin-face)
      (,(regexp-opt constants 'words) . font-lock-constant-face)
      ;; Function names in declarations

        ;; Inside a multi-line string.  Don't mess with indentation.
        nil)
       (cs
        ;; Inside a general comment
        (goto-char (car cs))
        (forward-char 1)
        (current-column))
       (t
        ;; Not in a multi-line string or comment
        (let ((indent 0)
              (inside-indenting-paren nil))
          ;; Count every enclosing brace, plus parens that follow
          ;; import, const, var, or type and indent according to
          ;; depth.  This simple rule does quite well, but also has a
