[0.23] Detect breaking changes

runtime/sema/check_binary_expression.go

@@ -26,6 +26,14 @@ import (
 
 func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression) ast.Repr {
 
+	var leftType, rightType, resultType Type
+	defer func() {
+		elaboration := checker.Elaboration
+		elaboration.BinaryExpressionLeftTypes[expression] = leftType
+		elaboration.BinaryExpressionRightTypes[expression] = rightType
+		elaboration.BinaryExpressionResultTypes[expression] = resultType
+	}()
+
 	// The left-hand side is always evaluated.
 	// However, the right-hand side might not necessarily be evaluated,
 	// e.g. in boolean logic or in nil-coalescing
@@ -55,7 +63,7 @@ func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression)
 	// Visit the expression, with contextually expected type. Use the expected type
 	// only for inferring wherever possible, but do not check for compatibility.
 	// Compatibility is checked separately for each operand kind.
-	leftType := checker.VisitExpressionWithForceType(expression.Left, expectedType, false)
+	leftType = checker.VisitExpressionWithForceType(expression.Left, expectedType, false)
 
 	leftIsInvalid := leftType.IsInvalidType()
 
@@ -111,7 +119,7 @@ func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression)
 			expectedType = leftType
 		}
 
-		rightType := checker.VisitExpressionWithForceType(expression.Right, expectedType, false)
+		rightType = checker.VisitExpressionWithForceType(expression.Right, expectedType, false)
 
 		rightIsInvalid := rightType.IsInvalidType()
 
@@ -122,18 +130,20 @@ func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression)
 			BinaryOperationKindNonEqualityComparison,
 			BinaryOperationKindBitwise:
 
-			return checker.checkBinaryExpressionArithmeticOrNonEqualityComparisonOrBitwise(
+			resultType = checker.checkBinaryExpressionArithmeticOrNonEqualityComparisonOrBitwise(
 				expression, operation, operationKind,
 				leftType, rightType,
 				leftIsInvalid, rightIsInvalid, anyInvalid,
 			)
+			return resultType
 
 		case BinaryOperationKindEquality:
-			return checker.checkBinaryExpressionEquality(
+			resultType = checker.checkBinaryExpressionEquality(
 				expression, operation, operationKind,
 				leftType, rightType,
 				leftIsInvalid, rightIsInvalid, anyInvalid,
 			)
+			return resultType
 
 		default:
 			return unsupportedOperation()
@@ -146,7 +156,7 @@ func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression)
 		// That means that resource invalidation and returns
 		// are not definite, but only potential.
 
-		rightType := checker.checkPotentiallyUnevaluated(func() Type {
+		rightType = checker.checkPotentiallyUnevaluated(func() Type {
 			var expectedType Type
 			if !leftIsInvalid {
 				if optionalLeftType, ok := leftType.(*OptionalType); ok {
@@ -162,22 +172,19 @@ func (checker *Checker) VisitBinaryExpression(expression *ast.BinaryExpression)
 
 		switch operationKind {
 		case BinaryOperationKindBooleanLogic:
-			return checker.checkBinaryExpressionBooleanLogic(
+			resultType = checker.checkBinaryExpressionBooleanLogic(
 				expression, operation, operationKind,
 				leftType, rightType,
 				leftIsInvalid, rightIsInvalid, anyInvalid,
 			)
+			return resultType
 
 		case BinaryOperationKindNilCoalescing:
-			resultType := checker.checkBinaryExpressionNilCoalescing(
+			resultType = checker.checkBinaryExpressionNilCoalescing(
 				expression, operation, operationKind,
 				leftType, rightType,
 				leftIsInvalid, rightIsInvalid, anyInvalid,
 			)
-
-			checker.Elaboration.BinaryExpressionResultTypes[expression] = resultType
-			checker.Elaboration.BinaryExpressionRightTypes[expression] = rightType
-
 			return resultType
 
 		default:

runtime/sema/check_conditional.go

@@ -63,7 +63,6 @@ func (checker *Checker) VisitIfStatement(statement *ast.IfStatement) ast.Repr {
 func (checker *Checker) VisitConditionalExpression(expression *ast.ConditionalExpression) ast.Repr {
 
 	thenType, elseType := checker.visitConditional(expression.Test, expression.Then, expression.Else)
-
 	if thenType == nil || elseType == nil {
 		panic(errors.NewUnreachableError())
 	}
@@ -96,6 +95,9 @@ func (checker *Checker) VisitConditionalExpression(expression *ast.ConditionalEx
 		)
 	}
 
+	checker.Elaboration.ConditionalExpressionThenType[expression] = thenType
+	checker.Elaboration.ConditionalExpressionElseType[expression] = elseType
+
 	return resultType
 }
 

runtime/sema/elaboration.go

@@ -54,6 +54,7 @@ type Elaboration struct {
 	ReturnStatementValueTypes           map[*ast.ReturnStatement]Type
 	ReturnStatementReturnTypes          map[*ast.ReturnStatement]Type
 	BinaryExpressionResultTypes         map[*ast.BinaryExpression]Type
+	BinaryExpressionLeftTypes           map[*ast.BinaryExpression]Type
 	BinaryExpressionRightTypes          map[*ast.BinaryExpression]Type
 	MemberExpressionMemberInfos         map[*ast.MemberExpression]MemberInfo
 	MemberExpressionExpectedTypes       map[*ast.MemberExpression]Type
@@ -90,6 +91,8 @@ type Elaboration struct {
 	IsResourceMoveIndexExpression map[*ast.IndexExpression]bool
 	IndexExpressionIndexedTypes   map[*ast.IndexExpression]ValueIndexableType
 	IndexExpressionIndexingTypes  map[*ast.IndexExpression]Type
+	ConditionalExpressionThenType map[*ast.ConditionalExpression]Type
+	ConditionalExpressionElseType map[*ast.ConditionalExpression]Type
 }
 
 func NewElaboration() *Elaboration {
@@ -117,6 +120,7 @@ func NewElaboration() *Elaboration {
 		ReturnStatementValueTypes:           map[*ast.ReturnStatement]Type{},
 		ReturnStatementReturnTypes:          map[*ast.ReturnStatement]Type{},
 		BinaryExpressionResultTypes:         map[*ast.BinaryExpression]Type{},
+		BinaryExpressionLeftTypes:           map[*ast.BinaryExpression]Type{},
 		BinaryExpressionRightTypes:          map[*ast.BinaryExpression]Type{},
 		MemberExpressionMemberInfos:         map[*ast.MemberExpression]MemberInfo{},
 		MemberExpressionExpectedTypes:       map[*ast.MemberExpression]Type{},
@@ -145,6 +149,8 @@ func NewElaboration() *Elaboration {
 		ReferenceExpressionBorrowTypes:      map[*ast.ReferenceExpression]*ReferenceType{},
 		IndexExpressionIndexedTypes:         map[*ast.IndexExpression]ValueIndexableType{},
 		IndexExpressionIndexingTypes:        map[*ast.IndexExpression]Type{},
+		ConditionalExpressionThenType:       map[*ast.ConditionalExpression]Type{},
+		ConditionalExpressionElseType:       map[*ast.ConditionalExpression]Type{},
 	}
 }
 

tools/analysis/config.go

@@ -19,6 +19,8 @@
 package analysis
 
 import (
+	"fmt"
+
 	"github.com/onflow/cadence/runtime/ast"
 	"github.com/onflow/cadence/runtime/common"
 )
@@ -40,3 +42,47 @@ type Config struct {
 		importRange ast.Range,
 	) (string, error)
 }
+
+func NewSimpleConfig(
+	mode LoadMode,
+	codes map[common.LocationID]string,
+	contractNames map[common.Address][]string,
+) *Config {
+	config := &Config{
+		Mode: mode,
+		ResolveAddressContractNames: func(
+			address common.Address,
+		) (
+			[]string,
+			error,
+		) {
+			names, ok := contractNames[address]
+			if !ok {
+				return nil, fmt.Errorf(
+					"missing contracts for address: %s",
+					address,
+				)
+			}
+			return names, nil
+		},
+		ResolveCode: func(
+			location common.Location,
+			importingLocation common.Location,
+			importRange ast.Range,
+		) (
+			string,
+			error,
+		) {
+			code, ok := codes[location.ID()]
+			if !ok {
+				return "", fmt.Errorf(
+					"import of unknown location: %s",
+					location,
+				)
+			}
+
+			return code, nil
+		},
+	}
+	return config
+}

tools/analysis/program.go

@@ -28,6 +28,7 @@ import (
 
 type Program struct {
 	Location    common.Location
+	Code        string
 	Program     *ast.Program
 	Elaboration *sema.Elaboration
 }

tools/analysis/programs.go

@@ -70,6 +70,7 @@ func (programs Programs) load(
 
 	programs[location.ID()] = &Program{
 		Location:    location,
+		Code:        code,
 		Program:     program,
 		Elaboration: elaboration,
 	}

tools/contract-analyzer/analyzer.go → tools/contract-analyzer/analyzers/analyzer.go

@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-package main
+package analyzers
 
 import (
 	"fmt"
@@ -25,12 +25,12 @@ import (
 	"github.com/onflow/cadence/tools/analysis"
 )
 
-var analyzers = map[string]*analysis.Analyzer{}
+var Analyzers = map[string]*analysis.Analyzer{}
 
 var analyzerNamePattern = regexp.MustCompile(`\w+`)
 
 func registerAnalyzer(name string, analyzer *analysis.Analyzer) {
-	if _, ok := analyzers[name]; ok {
+	if _, ok := Analyzers[name]; ok {
 		panic(fmt.Errorf("analyzer already exists: %s", name))
 	}
 
@@ -39,5 +39,5 @@ func registerAnalyzer(name string, analyzer *analysis.Analyzer) {
 
 	}
 
-	analyzers[name] = analyzer
+	Analyzers[name] = analyzer
 }