Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package imports

import "io"

import (
        _ "io"
)

import _ "io"

import (
        "io"
        "io"
        "io"
)

import (
        "io"
        aLongRename "io"

        b "io"
)

import (
        "unrenamed"
        renamed "renameMe"
        . "io"
        _ "io"
        "io"
        . "os"
)

// no newlines between consecutive single imports, but
// respect extra line breaks in the source (at most one empty line)
import _ "io"
import _ "io"
import _ "io"

import _ "os"
import _ "os"
import _ "os"

import _ "fmt"
import _ "fmt"
import _ "fmt"

import "foo"    // a comment
import "bar"    // a comment

import (
        _ "foo"
        // a comment
        "bar"
        "foo"   // a comment
        "bar"   // a comment
)

// comments + renames
import (
        "unrenamed"     // a comment
        renamed "renameMe"
        . "io"          /* a comment */
        _ "io/ioutil"   // a comment
        "io"            // testing alignment
        . "os"
        // a comment
)

// a case that caused problems in the past (comment placement)
import (
        . "fmt"
        "io"
        "malloc"        // for the malloc count test only
        "math"
        "strings"
        "testing"
)

// more import examples
import (
        "xxx"
        "much longer name"      // comment
        "short name"            // comment
)

import (
        _ "xxx"
        "much longer name"      // comment
)

import (
        mymath "math"
        "/foo/bar/long_package_path"    // a comment
)

import (
        "package_a"     // comment
        "package_b"
        my_better_c "package_c" // comment
        "package_d"             // comment
        my_e "package_e"        // comment

        "package_a"     // comment
        "package_bb"
        "package_ccc"   // comment
        "package_dddd"  // comment
)

// at least one empty line between declarations of different kind
import _ "io"

var _ int

// at least one empty line between declarations of the same kind
// if there is associated documentation (was issue 2570)
type T1 struct{}

// T2 comment
type T2 struct {
}       // should be a two-line struct

// T3 comment
type T2 struct {
}       // should be a two-line struct

// printing of constant literals
const (
        _       = "foobar"
        _       = "a۰۱۸"
        _       = "foo६४"
        _       = "bar９８７６"
        _       = 0
        _       = 1
        _       = 123456789012345678890
        _       = 01234567
        _       = 0xcafebabe
        _       = 0.
        _       = .0
        _       = 3.14159265
        _       = 1e0
        _       = 1e+100
        _       = 1e-100
        _       = 2.71828e-1000
        _       = 0i
        _       = 1i
        _       = 012345678901234567889i
        _       = 123456789012345678890i
        _       = 0.i
        _       = .0i
        _       = 3.14159265i
        _       = 1e0i
        _       = 1e+100i
        _       = 1e-100i
        _       = 2.71828e-1000i
        _       = 'a'
        _       = '\000'
        _       = '\xFF'
        _       = '\uff16'
        _       = '\U0000ff16'
        _       = `foobar`
        _       = `foo
---
---
bar`
)

func _() {
        type _ int
        type _ *int
        type _ []int
        type _ map[string]int
        type _ chan int
        type _ func() int

        var _ int
        var _ *int
        var _ []int
        var _ map[string]int
        var _ chan int
        var _ func() int

        type _ struct{}
        type _ *struct{}
        type _ []struct{}
        type _ map[string]struct{}
        type _ chan struct{}
        type _ func() struct{}

        type _ interface{}
        type _ *interface{}
        type _ []interface{}
        type _ map[string]interface{}
        type _ chan interface{}
        type _ func() interface{}

        var _ struct{}
        var _ *struct{}
        var _ []struct{}
        var _ map[string]struct{}
        var _ chan struct{}
        var _ func() struct{}

        var _ interface{}
        var _ *interface{}
        var _ []interface{}
        var _ map[string]interface{}
        var _ chan interface{}
        var _ func() interface{}
}

// don't lose blank lines in grouped declarations
const (
        _       int     = 0
        _       float   = 1

        _       string  = "foo"

        _       = iota
        _

        // a comment
        _

        _
)

type (
        _       int
        _       struct{}

        _       interface{}

        // a comment
        _       map[string]int
)

var (
        _       int     = 0
        _       float   = 1

        _       string  = "foo"

        _       bool

        // a comment
        _       bool
)

// don't lose blank lines in this struct
type _ struct {
        String  struct {
                Str, Len int
        }
        Slice   struct {
                Array, Len, Cap int
        }
        Eface   struct {
                Typ, Ptr int
        }

        UncommonType    struct {
                Name, PkgPath int
        }
        CommonType      struct {
                Size, Hash, Alg, Align, FieldAlign, String, UncommonType int
        }
        Type    struct {
                Typ, Ptr int
        }
        StructField     struct {
                Name, PkgPath, Typ, Tag, Offset int
        }
        StructType      struct {
                Fields int
        }
        PtrType struct {
                Elem int
        }
        SliceType       struct {
                Elem int
        }
        ArrayType       struct {
                Elem, Len int
        }

        Stktop  struct {
                Stackguard, Stackbase, Gobuf int
        }
        Gobuf   struct {
                Sp, Pc, G int
        }
        G       struct {
                Stackbase, Sched, Status, Alllink int
        }
}

// no blank lines in empty structs and interfaces, but leave 1- or 2-line layout alone
type _ struct{}
type _ struct {
}

type _ interface{}
type _ interface {
}

// no tabs for single or ungrouped decls
func _() {
        const xxxxxx = 0
        type x int
        var xxx int
        var yyyy float = 3.14
        var zzzzz = "bar"

        const (
                xxxxxx = 0
        )
        type (
                x int
        )
        var (
                xxx int
        )
        var (
                yyyy float = 3.14
        )
        var (
                zzzzz = "bar"
        )
}

// tabs for multiple or grouped decls
func _() {
        // no entry has a type
        const (
                zzzzzz  = 1
                z       = 2
                zzz     = 3
        )
        // some entries have a type
        const (
                xxxxxx                  = 1
                x                       = 2
                xxx                     = 3
                yyyyyyyy        float   = iota
                yyyy                    = "bar"
                yyy
                yy      = 2
        )
}

func _() {
        // no entry has a type
        var (
                zzzzzz  = 1
                z       = 2
                zzz     = 3
        )
        // no entry has a value
        var (
                _       int
                _       float
                _       string

                _       int     // comment
                _       float   // comment
                _       string  // comment
        )
        // some entries have a type
        var (
                xxxxxx          int
                x               float
                xxx             string
                yyyyyyyy        int     = 1234
                y               float   = 3.14
                yyyy                    = "bar"
                yyy             string  = "foo"
        )
        // mixed entries - all comments should be aligned
        var (
                a, b, c                 int
                x                       = 10
                d                       int                     // comment
                y                               = 20            // comment
                f, ff, fff, ffff        int     = 0, 1, 2, 3    // comment
        )
        // respect original line breaks
        var _ = []T{
                T{0x20, "Telugu"},
        }
        var _ = []T{
                // respect original line breaks
                T{0x20, "Telugu"},
        }
}

func _() {
        type (
                xxxxxx  int
                x       float
                xxx     string
                xxxxx   []x
                xx      struct{}
                xxxxxxx struct {
                        _, _    int
                        _       float
                }
                xxxx    chan<- string
        )
}

// alignment of "=" in consecutive lines (extended example from issue 1414)
const (
        umax    uint    = ^uint(0)              // maximum value for a uint
        bpu             = 1 << (5 + umax>>63)   // bits per uint
        foo
        bar     = -1
)

// typical enum
const (
        a       MyType  = iota
        abcd
        b
        c
        def
)

// excerpt from godoc.go
var (
        goroot          = flag.String("goroot", runtime.GOROOT(), "Go root directory")
        testDir         = flag.String("testdir", "", "Go root subdirectory - for testing only (faster startups)")
        pkgPath         = flag.String("path", "", "additional package directories (colon-separated)")
        filter          = flag.String("filter", "", "filter file containing permitted package directory paths")
        filterMin       = flag.Int("filter_minutes", 0, "filter file update interval in minutes; disabled if <= 0")
        filterDelay     delayTime       // actual filter update interval in minutes; usually filterDelay == filterMin, but filterDelay may back off exponentially
)

// formatting of structs
type _ struct{}

type _ struct { /* this comment should be visible */
}

type _ struct {
        // this comment should be visible and properly indented
}

type _ struct { // this comment must not change indentation
        f                       int
        f, ff, fff, ffff        int
}

type _ struct {
        string
}

type _ struct {
        string  // comment
}

type _ struct {
        string "tag"
}

type _ struct {
        string "tag"    // comment
}

type _ struct {
        f int
}

type _ struct {
        f int   // comment
}

type _ struct {
        f int "tag"
}

type _ struct {
        f int "tag"     // comment
}

type _ struct {
        bool
        a, b, c                 int
        int                     "tag"
        ES                              // comment
        float                   "tag"   // comment
        f                       int     // comment
        f, ff, fff, ffff        int     // comment
        g                       float   "tag"
        h                       float   "tag"   // comment
}

type _ struct {
        a, b,
        c, d    int     // this line should be indented
        u, v, w, x      float   // this line should be indented
        p, q,
        r, s    float   // this line should be indented
}

// difficult cases
type _ struct {
        bool            // comment
        text    []byte  // comment
}

// formatting of interfaces
type EI interface{}

type _ interface {
        EI
}

type _ interface {
        f()
        fffff()
}

type _ interface {
        EI
        f()
        fffffg()
}

type _ interface {      // this comment must not change indentation
        EI                              // here's a comment
        f()                             // no blank between identifier and ()
        fffff()                         // no blank between identifier and ()
        gggggggggggg(x, y, z int)       // hurray
}

// formatting of variable declarations
func _() {
        type day struct {
                n               int
                short, long     string
        }
        var (
                Sunday          = day{0, "SUN", "Sunday"}
                Monday          = day{1, "MON", "Monday"}
                Tuesday         = day{2, "TUE", "Tuesday"}
                Wednesday       = day{3, "WED", "Wednesday"}
                Thursday        = day{4, "THU", "Thursday"}
                Friday          = day{5, "FRI", "Friday"}
                Saturday        = day{6, "SAT", "Saturday"}
        )
}

// formatting of multi-line variable declarations
var a1, b1, c1 int      // all on one line

var a2, b2,
        c2 int  // this line should be indented

var (
        a3, b3,
        c3, d3  int     // this line should be indented
        a4, b4, c4      int     // this line should be indented
)

func _() {
        var privateKey2 = &Block{Type:  "RSA PRIVATE KEY",
                Headers:        map[string]string{},
                Bytes: []uint8{0x30, 0x82, 0x1, 0x3a, 0x2, 0x1, 0x0, 0x2,
                        0x41, 0x0, 0xb2, 0x99, 0xf, 0x49, 0xc4, 0x7d, 0xfa, 0x8c,
                        0xd4, 0x0, 0xae, 0x6a, 0x4d, 0x1b, 0x8a, 0x3b, 0x6a, 0x13,
                        0x64, 0x2b, 0x23, 0xf2, 0x8b, 0x0, 0x3b, 0xfb, 0x97, 0x79,
                },
        }
}

func _() {
        var Universe = Scope{
                Names: map[string]*Ident{
                        // basic types
                        "bool":         nil,
                        "byte":         nil,
                        "int8":         nil,
                        "int16":        nil,
                        "int32":        nil,
                        "int64":        nil,
                        "uint8":        nil,
                        "uint16":       nil,
                        "uint32":       nil,
                        "uint64":       nil,
                        "float32":      nil,
                        "float64":      nil,
                        "string":       nil,

                        // convenience types
                        "int":          nil,
                        "uint":         nil,
                        "uintptr":      nil,
                        "float":        nil,

                        // constants
                        "false":        nil,
                        "true":         nil,
                        "iota":         nil,
                        "nil":          nil,

                        // functions
                        "cap":          nil,
                        "len":          nil,
                        "new":          nil,
                        "make":         nil,
                        "panic":        nil,
                        "panicln":      nil,
                        "print":        nil,
                        "println":      nil,
                },
        }
}

// alignment of map composite entries
var _ = map[int]int{
        // small key sizes: always align even if size ratios are large
        a:                      a,
        abcdefghabcdefgh:       a,
        ab:                     a,
        abc:                    a,
        abcdefgabcdefg:         a,
        abcd:                   a,
        abcde:                  a,
        abcdef:                 a,

        // mixed key sizes: align when key sizes change within accepted ratio
        abcdefgh:               a,
        abcdefghabcdefg:        a,
        abcdefghij:             a,
        abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij: a,      // outlier - do not align with previous line
        abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij:           a,      // align with previous line

        ab:     a,      // do not align with previous line
        abcde:  a,      // align with previous line
}

func _() {
        var _ = T{
                a,      // must introduce trailing comma
        }
}

// formatting of function results
func _() func()                         {}
func _() func(int)                      { return nil }
func _() func(int) int                  { return nil }
func _() func(int) func(int) func()     { return nil }

// formatting of consecutive single-line functions
func _()        {}
func _()        {}
func _()        {}

func _()        {}      // an empty line before this function
func _()        {}
func _()        {}

func _()                { f(1, 2, 3) }
func _(x int) int       { y := x; return y + 1 }
func _() int            { type T struct{}; var x T; return x }

// these must remain multi-line since they are multi-line in the source
func _() {
        f(1, 2, 3)
}
func _(x int) int {
        y := x
        return y + 1
}
func _() int {
        type T struct{}
        var x T
        return x
}

// making function declarations safe for new semicolon rules
func _() { /* multi-line func because of comment */
}

func _() {
        /* multi-line func because block is on multiple lines */
}

// ellipsis parameters
func _(...int)
func _(...*int)
func _(...[]int)
func _(...struct{})
func _(bool, ...interface{})
func _(bool, ...func())
func _(bool, ...func(...int))
func _(bool, ...map[string]int)
func _(bool, ...chan int)

func _(b bool, x ...int)
func _(b bool, x ...*int)
func _(b bool, x ...[]int)
func _(b bool, x ...struct{})
func _(x ...interface{})
func _(x ...func())
func _(x ...func(...int))
func _(x ...map[string]int)
func _(x ...chan int)

// these parameter lists must remain multi-line since they are multi-line in the source
func _(bool,
        int) {
}
func _(x bool,
        y int) {
}
func _(x,
        y bool) {
}
func _(bool,    // comment
        int) {
}
func _(x bool,  // comment
        y int) {
}
func _(x,       // comment
        y bool) {
}
func _(bool,    // comment
        // comment
        int) {
}
func _(x bool,  // comment
        // comment
        y int) {
}
func _(x,       // comment
        // comment
        y bool) {
}
func _(bool,
        // comment
        int) {
}
func _(x bool,
        // comment
        y int) {
}
func _(x,
        // comment
        y bool) {
}
func _(x,       // comment
        y,      // comment
        z bool) {
}
func _(x,       // comment
        y,      // comment
        z bool) {
}
func _(x int,   // comment
        y float,        // comment
        z bool) {
}

// properly indent multi-line signatures
func ManageStatus(in <-chan *Status, req <-chan Request,
        stat chan<- *TargetInfo,
        TargetHistorySize int) {
}

func MultiLineSignature0(
        a, b, c int,
) {
}

func MultiLineSignature1(
        a, b, c int,
        u, v, w float,
) {
}

func MultiLineSignature2(
        a, b,
        c int,
) {
}

func MultiLineSignature3(
        a, b,
        c int, u, v,
        w float,
        x ...int) {
}

func MultiLineSignature4(
        a, b, c int,
        u, v,
        w float,
        x ...int) {
}

func MultiLineSignature5(
        a, b, c int,
        u, v, w float,
        p, q,
        r string,
        x ...int) {
}

// make sure it also works for methods in interfaces
type _ interface {
        MultiLineSignature0(
                a, b, c int,
        )

        MultiLineSignature1(
                a, b, c int,
                u, v, w float,
        )

        MultiLineSignature2(
                a, b,
                c int,
        )

        MultiLineSignature3(
                a, b,
                c int, u, v,
                w float,
                x ...int)

        MultiLineSignature4(
                a, b, c int,
                u, v,
                w float,
                x ...int)

        MultiLineSignature5(
                a, b, c int,
                u, v, w float,
                p, q,
                r string,
                x ...int)
}