Run gofmt over the code

clientapi/routing/sendevent.go

@@ -63,6 +63,7 @@ var sendEventDuration = prometheus.NewHistogramVec(
 )
 
 // SendEvent implements:
+//
 //	/rooms/{roomID}/send/{eventType}
 //	/rooms/{roomID}/send/{eventType}/{txnID}
 //	/rooms/{roomID}/state/{eventType}/{stateKey}

clientapi/routing/threepid.go

@@ -38,6 +38,7 @@ type threePIDsResponse struct {
 }
 
 // RequestEmailToken implements:
+//
 //	POST /account/3pid/email/requestToken
 //	POST /register/email/requestToken
 func RequestEmailToken(req *http.Request, threePIDAPI api.ClientUserAPI, cfg *config.ClientAPI) util.JSONResponse {

clientapi/routing/voip.go

@@ -30,6 +30,7 @@ import (
 )
 
 // RequestTurnServer implements:
+//
 //	GET /voip/turnServer
 func RequestTurnServer(req *http.Request, device *api.Device, cfg *config.ClientAPI) util.JSONResponse {
 	turnConfig := cfg.TURN

cmd/dendrite-upgrade-tests/main.go

@@ -47,7 +47,9 @@ const HEAD = "HEAD"
 // We cannot use the dockerfile associated with the repo with each version sadly due to changes in
 // Docker versions. Specifically, earlier Dendrite versions are incompatible with newer Docker clients
 // due to the error:
+//
 //	When using COPY with more than one source file, the destination must be a directory and end with a /
+//
 // We need to run a postgres anyway, so use the dockerfile associated with Complement instead.
 const Dockerfile = `FROM golang:1.18-stretch as build
 RUN apt-get update && apt-get install -y postgresql
@@ -95,7 +97,9 @@ CMD /build/run_dendrite.sh `
 const dendriteUpgradeTestLabel = "dendrite_upgrade_test"
 
 // downloadArchive downloads an arbitrary github archive of the form:
+//
 //	https://github.com/matrix-org/dendrite/archive/v0.3.11.tar.gz
+//
 // and re-tarballs it without the top-level directory which contains branch information. It inserts
 // the contents of `dockerfile` as a root file `Dockerfile` in the re-tarballed directory such that
 // you can directly feed the retarballed archive to `ImageBuild` to have it run said dockerfile.

cmd/dendritejs-pinecone/jsServer.go

@@ -34,8 +34,11 @@ type JSServer struct {
 
 // OnRequestFromJS is the function that JS will invoke when there is a new request.
 // The JS function signature is:
+//
 //	function(reqString: string): Promise<{result: string, error: string}>
+//
 // Usage is like:
+//
 //	const res = await global._go_js_server.fetch(reqString);
 //	if (res.error) {
 //	  // handle error: this is a 'network' error, not a non-2xx error.

federationapi/consumers/roomserver.go

@@ -208,9 +208,10 @@ func (s *OutputRoomEventConsumer) processMessage(ore api.OutputNewRoomEvent, rew
 // joinedHostsAtEvent works out a list of matrix servers that were joined to
 // the room at the event (including peeking ones)
 // It is important to use the state at the event for sending messages because:
-//   1) We shouldn't send messages to servers that weren't in the room.
-//   2) If a server is kicked from the rooms it should still be told about the
+//  1. We shouldn't send messages to servers that weren't in the room.
+//  2. If a server is kicked from the rooms it should still be told about the
 //     kick event,
+//
 // Usually the list can be calculated locally, but sometimes it will need fetch
 // events from the room server.
 // Returns an error if there was a problem talking to the room server.

federationapi/routing/join.go

@@ -435,11 +435,11 @@ func SendJoin(
 // a restricted room join. If the room version does not support restricted
 // joins then this function returns with no side effects. This returns three
 // values:
-// * an optional JSON response body (i.e. M_UNABLE_TO_AUTHORISE_JOIN) which
+//   - an optional JSON response body (i.e. M_UNABLE_TO_AUTHORISE_JOIN) which
 //     should always be sent back to the client if one is specified
-// * a user ID of an authorising user, typically a user that has power to
+//   - a user ID of an authorising user, typically a user that has power to
 //     issue invites in the room, if one has been found
-// * an error if there was a problem finding out if this was allowable,
+//   - an error if there was a problem finding out if this was allowable,
 //     like if the room version isn't known or a problem happened talking to
 //     the roomserver
 func checkRestrictedJoin(

keyserver/internal/device_list_update.go

@@ -66,12 +66,14 @@ func init() {
 //   - We don't have unbounded growth in proportion to the number of servers (this is more important in a P2P world where
 //     we have many many servers)
 //   - We can adjust concurrency (at the cost of memory usage) by tuning N, to accommodate mobile devices vs servers.
+//
 // The downsides are that:
 //   - Query requests can get queued behind other servers if they hash to the same worker, even if there are other free
 //     workers elsewhere. Whilst suboptimal, provided we cap how long a single request can last (e.g using context timeouts)
 //     we guarantee we will get around to it. Also, more users on a given server does not increase the number of requests
 //     (as /keys/query allows multiple users to be specified) so being stuck behind matrix.org won't materially be any worse
 //     than being stuck behind foo.bar
+//
 // In the event that the query fails, a lock is acquired and the server name along with the time to wait before retrying is
 // set in a map. A restarter goroutine periodically probes this map and injects servers which are ready to be retried.
 type DeviceListUpdater struct {

roomserver/internal/input/input.go

@@ -62,6 +62,7 @@ import (
 //
 //	A BC *  -> positions of each consumer (* = ephemeral)
 //	⌄ ⌄⌄ ⌄
+//
 // ABAABCAABCAA  -> newest (letter = subject for each message)
 //
 // In this example, A is still processing an event but has two

roomserver/internal/perform/perform_backfill.go

@@ -523,6 +523,7 @@ func (b *backfillRequester) ProvideEvents(roomVer gomatrixserverlib.RoomVersion,
 
 // joinEventsFromHistoryVisibility returns all CURRENTLY joined members if our server can read the room history
 // TODO: Long term we probably want a history_visibility table which stores eventNID | visibility_enum so we can just
+//
 //	pull all events and then filter by that table.
 func joinEventsFromHistoryVisibility(
 	ctx context.Context, db storage.Database, roomID string, stateEntries []types.StateEntry,

roomserver/storage/tables/interface.go

@@ -178,7 +178,9 @@ type StrippedEvent struct {
 }
 
 // ExtractContentValue from the given state event. For example, given an m.room.name event with:
+//
 //	content: { name: "Foo" }
+//
 // this returns "Foo".
 func ExtractContentValue(ev *gomatrixserverlib.HeaderedEvent) string {
 	content := ev.Content()

setup/mscs/msc2836/msc2836_test.go

@@ -32,15 +32,19 @@ var (
 )
 
 // Basic sanity check of MSC2836 logic. Injects a thread that looks like:
+//
 //	 A
 //	 |
 //	 B
 //	/ \
+//
 // C   D
+//
 //	 /|\
 //	E F G
 //	|
 //	H
+//
 // And makes sure POST /event_relationships works with various parameters
 func TestMSC2836(t *testing.T) {
 	alice := "@alice:localhost"

syncapi/internal/keychange_test.go

@@ -371,6 +371,7 @@ func TestKeyChangeCatchupChangeAndLeft(t *testing.T) {
 //     which are only relevant when actively sending events I think? And if Alice does need the keys she knows
 //     charlie's (user_id, device_id) so can just hit /keys/query - no need to keep updated about it because she
 //     doesn't share any rooms with him.
+//
 // Ergo, we put them in `left` as it is simpler.
 func TestKeyChangeCatchupChangeAndLeftSameRoom(t *testing.T) {
 	newShareUser := "@berta:localhost"

syncapi/storage/tables/interface.go

@@ -122,12 +122,14 @@ type CurrentRoomState interface {
 //
 // We persist the previous event IDs as well, one per row, so when we do fetch even
 // earlier events we can simply delete rows which referenced it. Consider the graph:
+//
 //	    A
 //	    |   Event C has 1 prev_event ID: A.
 //	B   C
 //	|___|   Event D has 2 prev_event IDs: B and C.
 //	  |
 //	  D
+//
 // The earliest known event we have is D, so this table has 2 rows.
 // A backfill request gives us C but not B. We delete rows where prev_event=C. This
 // still means that D is a backwards extremity as we do not have event B. However, event

userapi/storage/sqlite3/stats_table.go

@@ -297,7 +297,9 @@ func (s *statsStatements) monthlyUsers(ctx context.Context, txn *sql.Tx) (result
 	return
 }
 
-/* R30Users counts the number of 30 day retained users, defined as:
+/*
+	R30Users counts the number of 30 day retained users, defined as:
+
 - Users who have created their accounts more than 30 days ago
 - Where last seen at most 30 days ago
 - Where account creation and last_seen are > 30 days apart
@@ -334,7 +336,9 @@ func (s *statsStatements) r30Users(ctx context.Context, txn *sql.Tx) (map[string
 	return result, rows.Err()
 }
 
-/* R30UsersV2 counts the number of 30 day retained users, defined as users that:
+/*
+	R30UsersV2 counts the number of 30 day retained users, defined as users that:
+
 - Appear more than once in the past 60 days
 - Have more than 30 days between the most and least recent appearances that occurred in the past 60 days.
 */