                        (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

                     (and depth
                          (not (eq (char-after (caar depth)) ?\{)))))
                  (t
                   ;; Except when the current line closes the previous line's 
                   ;; scope, anything else is a continuation line.
                   (not current-line-closes-scope)))
            (incf indent tab-width))
          (max indent 0)))))))

(defun go-mode-indent-line ()

    st)
  "Syntax table for Go mode.")

(defvar go-mode-keywords
  '("break"    "default"     "func"   "interface" "select"
    "case"     "defer"       "go"     "map"       "struct"
    "chan"     "else"        "goto"   "package"   "switch"
    "const"    "fallthrough" "if"     "range"     "type"
    "continue" "for"         "import" "return"    "var")
  "All keywords in the Go language.  Used for font locking and
some syntax analysis.")

(defvar go-mode-font-lock-keywords
  (let ((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 go-mode-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
