*: apply go 1.19 formatter heuristics

And make manual corrections where needed. See the "Common mistakes
and pitfalls" section of https://tip.golang.org/doc/comment.

pkg/compiler/analysis.go

@@ -210,12 +210,13 @@ func lastStmtIsReturn(body *ast.BlockStmt) (b bool) {
 
 // analyzePkgOrder sets the order in which packages should be processed.
 // From Go spec:
-//   A package with no imports is initialized by assigning initial values to all its package-level variables
-//   followed by calling all init functions in the order they appear in the source, possibly in multiple files,
-//   as presented to the compiler. If a package has imports, the imported packages are initialized before
-//   initializing the package itself. If multiple packages import a package, the imported package
-//   will be initialized only once. The importing of packages, by construction, guarantees
-//   that there can be no cyclic initialization dependencies.
+//
+//	A package with no imports is initialized by assigning initial values to all its package-level variables
+//	followed by calling all init functions in the order they appear in the source, possibly in multiple files,
+//	as presented to the compiler. If a package has imports, the imported packages are initialized before
+//	initializing the package itself. If multiple packages import a package, the imported package
+//	will be initialized only once. The importing of packages, by construction, guarantees
+//	that there can be no cyclic initialization dependencies.
 func (c *codegen) analyzePkgOrder() {
 	seen := make(map[string]bool)
 	info := c.buildInfo.program[0]

pkg/compiler/codegen.go

@@ -1341,19 +1341,21 @@ func (c *codegen) isCallExprSyscall(e ast.Expr) bool {
 
 // processDefers emits code for `defer` statements.
 // TRY-related opcodes handle exception as follows:
-// 1. CATCH block is executed only if exception has occurred.
-// 2. FINALLY block is always executed, but after catch block.
+//  1. CATCH block is executed only if exception has occurred.
+//  2. FINALLY block is always executed, but after catch block.
+//
 // Go `defer` statements are a bit different:
-// 1. `defer` is always executed irregardless of whether an exception has occurred.
-// 2. `recover` can or can not handle a possible exception.
+//  1. `defer` is always executed irregardless of whether an exception has occurred.
+//  2. `recover` can or can not handle a possible exception.
+//
 // Thus, we use the following approach:
-// 1. Throwed exception is saved in a static field X, static fields Y and it is set to true.
-// 2. For each defer local there is a dedicated local variable which is set to 1 if `defer` statement
-//    is encountered during an actual execution.
-// 3. CATCH and FINALLY blocks are the same, and both contain the same CALLs.
-// 4. Right before the CATCH block, check a variable from (2). If it is null, jump to the end of CATCH+FINALLY block.
-// 5. In CATCH block we set Y to true and emit default return values if it is the last defer.
-// 6. Execute FINALLY block only if Y is false.
+//  1. Throwed exception is saved in a static field X, static fields Y and it is set to true.
+//  2. For each defer local there is a dedicated local variable which is set to 1 if `defer` statement
+//     is encountered during an actual execution.
+//  3. CATCH and FINALLY blocks are the same, and both contain the same CALLs.
+//  4. Right before the CATCH block, check a variable from (2). If it is null, jump to the end of CATCH+FINALLY block.
+//  5. In CATCH block we set Y to true and emit default return values if it is the last defer.
+//  6. Execute FINALLY block only if Y is false.
 func (c *codegen) processDefers() {
 	for i := len(c.scope.deferStack) - 1; i >= 0; i-- {
 		stmt := c.scope.deferStack[i]
@@ -1399,10 +1401,10 @@ func (c *codegen) processDefers() {
 
 // emitExplicitConvert handles `someType(someValue)` conversions between string/[]byte.
 // Rules for conversion:
-// 1. interop.* types are converted to ByteArray if not already.
-// 2. Otherwise, convert between ByteArray/Buffer.
-// 3. Rules for types which are not string/[]byte should already
-//    be enforced by go parser.
+//  1. interop.* types are converted to ByteArray if not already.
+//  2. Otherwise, convert between ByteArray/Buffer.
+//  3. Rules for types which are not string/[]byte should already
+//     be enforced by go parser.
 func (c *codegen) emitExplicitConvert(from, to types.Type) {
 	if isInteropPath(to.String()) {
 		if isByteSlice(from) && !isString(from) {
@@ -1859,10 +1861,10 @@ func (c *codegen) convertBuiltin(expr *ast.CallExpr) {
 // transformArgs returns a list of function arguments
 // which should be put on stack.
 // There are special cases for builtins:
-// 1. With FromAddress, parameter conversion is happening at compile-time
-//    so there is no need to push parameters on stack and perform an actual call
-// 2. With panic, the generated code depends on the fact if an argument was nil or a string;
-//    so, it should be handled accordingly.
+//  1. With FromAddress, parameter conversion is happening at compile-time
+//     so there is no need to push parameters on stack and perform an actual call
+//  2. With panic, the generated code depends on the fact if an argument was nil or a string;
+//     so, it should be handled accordingly.
 func transformArgs(fs *funcScope, fun ast.Expr, args []ast.Expr) []ast.Expr {
 	switch f := fun.(type) {
 	case *ast.SelectorExpr:

pkg/compiler/inline.go

@@ -15,11 +15,12 @@ import (
 
 // inlineCall inlines call of n for function represented by f.
 // Call `f(a,b)` for definition `func f(x,y int)` is translated to block:
-//   {
-//      x := a
-//      y := b
-//      <inline body of f directly>
-//   }
+//
+//	{
+//	   x := a
+//	   y := b
+//	   <inline body of f directly>
+//	}
 func (c *codegen) inlineCall(f *funcScope, n *ast.CallExpr) {
 	offSz := len(c.inlineContext)
 	c.inlineContext = append(c.inlineContext, inlineContextSingle{