[chore] update dependencies, bump to Go 1.19.1 (#826)

* update dependencies, bump Go version to 1.19

* bump test image Go version

* update golangci-lint

* update gotosocial-drone-build

* sign

* linting, go fmt

* update swagger docs

* update swagger docs

* whitespace

* update contributing.md

* fuckin whoopsie doopsie

* linterino, linteroni

* fix followrequest test not starting processor

* fix other api/client tests not starting processor

* fix remaining tests where processor not started

* bump go-runners version

* don't check last-webfingered-at, processor may have updated this

* update swagger command

* update bun to latest version

* fix embed to work the same as before with new bun

Signed-off-by: kim <grufwub@gmail.com>
Co-authored-by: tsmethurst <tobi.smethurst@protonmail.com>

1 files changed, 46 insertions, 27 deletions

diff --git a/vendor/modernc.org/cc/v3/parser.go b/vendor/modernc.org/cc/v3/parser.go
index d73b2c6b3..a2b5f3c79 100644
--- a/vendor/modernc.org/cc/v3/parser.go
+++ b/vendor/modernc.org/cc/v3/parser.go
@@ -3162,28 +3162,49 @@ func (p *parser) designator(acceptCol bool) (*Designator, bool) {
 // 	iteration-statement
 // 	jump-statement
 //	asm-statement
-func (p *parser) statement() *Statement {
-	switch p.rune() {
-	case IDENTIFIER:
-		if p.peek(false) == ':' {
-			return &Statement{Case: StatementLabeled, LabeledStatement: p.labeledStatement()}
+func (p *parser) statement() (r *Statement) {
+	var r0 *Statement
+	var prevLS, ls *LabeledStatement
+
+	defer func() {
+		if ls != nil {
+			ls.Statement = r
+			r = r0
 		}
+	}()
 
-		return &Statement{Case: StatementExpr, ExpressionStatement: p.expressionStatement()}
-	case '{':
-		return &Statement{Case: StatementCompound, CompoundStatement: p.compoundStatement(nil, nil)}
-	case IF, SWITCH:
-		return &Statement{Case: StatementSelection, SelectionStatement: p.selectionStatement()}
-	case WHILE, DO, FOR:
-		return &Statement{Case: StatementIteration, IterationStatement: p.iterationStatement()}
-	case GOTO, BREAK, CONTINUE, RETURN:
-		return &Statement{Case: StatementJump, JumpStatement: p.jumpStatement()}
-	case CASE, DEFAULT:
-		return &Statement{Case: StatementLabeled, LabeledStatement: p.labeledStatement()}
-	case ASM:
-		return &Statement{Case: StatementAsm, AsmStatement: p.asmStatement()}
-	default:
-		return &Statement{Case: StatementExpr, ExpressionStatement: p.expressionStatement()}
+	for {
+		switch p.rune() {
+		case IDENTIFIER:
+			switch {
+			case p.peek(false) == ':':
+				ls = p.labeledStatement()
+			default:
+				return &Statement{Case: StatementExpr, ExpressionStatement: p.expressionStatement()}
+			}
+		case '{':
+			return &Statement{Case: StatementCompound, CompoundStatement: p.compoundStatement(nil, nil)}
+		case IF, SWITCH:
+			return &Statement{Case: StatementSelection, SelectionStatement: p.selectionStatement()}
+		case WHILE, DO, FOR:
+			return &Statement{Case: StatementIteration, IterationStatement: p.iterationStatement()}
+		case GOTO, BREAK, CONTINUE, RETURN:
+			return &Statement{Case: StatementJump, JumpStatement: p.jumpStatement()}
+		case CASE, DEFAULT:
+			ls = p.labeledStatement()
+		case ASM:
+			return &Statement{Case: StatementAsm, AsmStatement: p.asmStatement()}
+		default:
+			return &Statement{Case: StatementExpr, ExpressionStatement: p.expressionStatement()}
+		}
+
+		switch {
+		case r0 == nil:
+			r0 = &Statement{Case: StatementLabeled, LabeledStatement: ls}
+		default:
+			prevLS.Statement = &Statement{Case: StatementLabeled, LabeledStatement: ls}
+		}
+		prevLS = ls
 	}
 }
 
@@ -3220,7 +3241,7 @@ func (p *parser) labeledStatement() (r *LabeledStatement) {
 		p.block.hasLabel()
 		r = &LabeledStatement{
 			Case: LabeledStatementLabel, Token: t, Token2: t2, AttributeSpecifierList: attr,
-			Statement: p.statement(), lexicalScope: p.declScope, block: p.block,
+			lexicalScope: p.declScope, block: p.block,
 		}
 		p.declScope.declare(t.Value, r)
 		return r
@@ -3246,8 +3267,7 @@ func (p *parser) labeledStatement() (r *LabeledStatement) {
 			return &LabeledStatement{
 				Case: LabeledStatementRange, Token: t, ConstantExpression: e,
 				Token2: t2, ConstantExpression2: e2, Token3: t3,
-				Statement: p.statement(), lexicalScope: p.declScope,
-				block: p.block,
+				lexicalScope: p.declScope, block: p.block,
 			}
 		case ':':
 			t2 = p.shift()
@@ -3256,8 +3276,7 @@ func (p *parser) labeledStatement() (r *LabeledStatement) {
 		}
 		return &LabeledStatement{
 			Case: LabeledStatementCaseLabel, Token: t, ConstantExpression: e,
-			Token2: t2, Statement: p.statement(), lexicalScope: p.declScope,
-			block: p.block,
+			Token2: t2, lexicalScope: p.declScope, block: p.block,
 		}
 	case DEFAULT:
 		if p.switches == 0 {
@@ -3271,12 +3290,12 @@ func (p *parser) labeledStatement() (r *LabeledStatement) {
 			p.err("expected :")
 		}
 		return &LabeledStatement{
-			Case: LabeledStatementDefault, Token: t, Token2: t2, Statement: p.statement(),
+			Case: LabeledStatementDefault, Token: t, Token2: t2,
 			lexicalScope: p.declScope, block: p.block,
 		}
 	default:
 		p.err("expected labeled-statement")
-		return nil
+		return &LabeledStatement{}
 	}
 }