clerk @ 747f2da9ee083048a180a9c625f14bc221f24606

···
        41
        41
         	return a

      
        42
        42
         }

      
        43
        43
         

      
        44
        
        -func TxDuplicateKey(tx *ast.Transaction) string {

      
        
        44
        +func txDuplicateKey(tx *ast.Transaction, names []string) string {

      
        45
        45
         	var b strings.Builder

      
        46
        46
         	b.WriteString(tx.Date.String())

      
        47
        47
         	b.WriteByte('|')

      ···
        49
        49
         		b.WriteString(tx.Payee.Name)

      
        50
        50
         	}

      
        51
        51
         	b.WriteByte('|')

      
        52
        
        -	for _, p := range tx.Postings {

      
        53
        
        -		b.WriteString(p.Account.String())

      
        
        52
        +	for i := range tx.Postings {

      
        
        53
        +		b.WriteString(names[i])

      
        54
        54
         		b.WriteByte(',')

      
        55
        55
         	}

      
        56
        56
         	return b.String()

      ···
        99
        99
         	case *ast.Comment:

      
        100
        100
         		a.addCommentTags(fileIndex, nil, e)

      
        101
        101
         	case *ast.Transaction:

      
        
        102
        +		a.addPayee(fileIndex, e.Payee)

      
        102
        103
         		a.Transactions = append(a.Transactions, e)

      
        103
        
        -		a.addPostings(fileIndex, e.Postings, &e.Date)

      
        104
        
        -		a.addPayee(fileIndex, e.Payee)

      
        
        104
        +		a.TransactionsCountByDate[e.Date.String()]++

      
        
        105
        +

      
        
        106
        +		names := make([]string, len(e.Postings))

      
        
        107
        +		for i, p := range e.Postings {

      
        
        108
        +			names[i] = p.Account.String()

      
        
        109
        +		}

      
        
        110
        +		a.addPostings(fileIndex, e.Postings, names, &e.Date)

      
        
        111
        +

      
        105
        112
         		a.addCommentTags(fileIndex, &e.Date, e.Comment)

      
        106
        113
         		for _, c := range e.HeaderComments {

      
        107
        114
         			a.addCommentTags(fileIndex, &e.Date, c)

      
        108
        115
         		}

      
        109
        
        -		key := TxDuplicateKey(e)

      
        
        116
        +		key := txDuplicateKey(e, names)

      
        110
        117
         		a.TransactionsByKey[key] = append(a.TransactionsByKey[key], e)

      
        111
        
        -		a.TransactionsCountByDate[e.Date.String()]++

      
        112
        118
         	case *ast.PeriodicTransaction:

      
        113
        119
         		a.PeriodicTransactions = append(a.PeriodicTransactions, e)

      
        114
        
        -		a.addPostings(fileIndex, e.Postings, nil)

      
        
        120
        +		a.addPostings(fileIndex, e.Postings, nil, nil)

      
        115
        121
         		a.addCommentTags(fileIndex, nil, e.Comment)

      
        116
        122
         		for _, c := range e.HeaderComments {

      
        117
        123
         			a.addCommentTags(fileIndex, nil, c)

      
        118
        124
         		}

      
        119
        125
         	case *ast.AutomatedTransaction:

      
        120
        126
         		a.AutomatedTransactions = append(a.AutomatedTransactions, e)

      
        121
        
        -		a.addPostings(fileIndex, e.Postings, nil)

      
        
        127
        +		a.addPostings(fileIndex, e.Postings, nil, nil)

      
        122
        128
         		a.addCommentTags(fileIndex, nil, e.Comment)

      
        123
        129
         		for _, c := range e.HeaderComments {

      
        124
        130
         			a.addCommentTags(fileIndex, nil, c)

      ···
        224
        230
         	info.UsedCount++

      
        225
        231
         }

      
        226
        232
         

      
        227
        
        -func (a *Analysis) addPostings(fileIndex int, postings []*ast.Posting, date *ast.Date) {

      
        228
        
        -	for _, posting := range postings {

      
        229
        
        -		aname := posting.Account.String()

      
        
        233
        +func (a *Analysis) addPostings(fileIndex int, postings []*ast.Posting, names []string, date *ast.Date) {

      
        
        234
        +	if names == nil {

      
        
        235
        +		names = make([]string, len(postings))

      
        
        236
        +		for i, p := range postings {

      
        
        237
        +			names[i] = p.Account.String()

      
        
        238
        +		}

      
        
        239
        +	}

      
        
        240
        +	for i, posting := range postings {

      
        
        241
        +		aname := names[i]

      
        230
        242
         		info, ok := a.Accounts[aname]

      
        231
        243
         		if !ok {

      
        232
        244
         			info = &AccountInfo{}

      

···
        163
        163
         	if len(a.Name) == 0 {

      
        164
        164
         		return ""

      
        165
        165
         	}

      
        166
        
        -	var name strings.Builder

      
        167
        
        -	name.Grow(len(a.Name))

      
        168
        
        -	name.WriteString(a.Name[0].Name)

      
        
        166
        +	var b strings.Builder

      
        
        167
        +	b.Grow(len(a.Name))

      
        
        168
        +	b.WriteString(a.Name[0].Name)

      
        169
        169
         	for _, s := range a.Name[1:] {

      
        170
        
        -		name.WriteByte(':')

      
        171
        
        -		name.WriteString(s.Name)

      
        
        170
        +		b.WriteByte(':')

      
        
        171
        +		b.WriteString(s.Name)

      
        172
        172
         	}

      
        173
        
        -	return name.String()

      
        
        173
        +	return b.String()

      
        174
        174
         }