lint

var Analyzers = map[string]*analysis.Analyzer{}

var AuthAccountParameterAnalyzer = (func() *analysis.Analyzer {

	elementFilter := []ast.Element{
		(*ast.FunctionDeclaration)(nil),
		(*ast.SpecialFunctionDeclaration)(nil),
	}

	return &analysis.Analyzer{
		Description: "Detects functions with AuthAccount type parameters",
		Requires: []*analysis.Analyzer{
			analysis.InspectorAnalyzer,
		},
		Run: func(pass *analysis.Pass) interface{} {
			inspector := pass.ResultOf[analysis.InspectorAnalyzer].(*ast.Inspector)

			location := pass.Program.Location
			report := pass.Report

			inspector.Preorder(
				elementFilter,
				func(element ast.Element) {
					var parameterList *ast.ParameterList
					switch declaration := element.(type) {
					case *ast.FunctionDeclaration:
						parameterList = declaration.ParameterList
					case *ast.SpecialFunctionDeclaration:
						if declaration.DeclarationKind() == common.DeclarationKindInitializer {
							parameterList = declaration.FunctionDeclaration.ParameterList
						}
					}

					if parameterList == nil {
						return
					}

					for _, parameter := range parameterList.Parameters {
						nominalType, ok := parameter.TypeAnnotation.Type.(*ast.NominalType)
						if ok && nominalType.Identifier.Identifier == "AuthAccount" {
							report(
								analysis.Diagnostic{
									Location:         location,
									Range:            ast.NewRangeFromPositioned(nil, element),
									Category:         UpdateCategory,
									Message:          "It is an anti-pattern to pass AuthAccount to functions.",
									SecondaryMessage: "Consider using Capabilities instead.",
								},
							)
						}
					}
				},
			)

			return nil
		},
	}
})()

var DeprecatedMemberAnalyzer = (func() *analysis.Analyzer {

	elementFilter := []ast.Element{
		(*ast.MemberExpression)(nil),
	}

	return &analysis.Analyzer{
		Description: "Detects uses of deprecated members",
		Requires: []*analysis.Analyzer{
			analysis.InspectorAnalyzer,
		},
		Run: func(pass *analysis.Pass) interface{} {
			inspector := pass.ResultOf[analysis.InspectorAnalyzer].(*ast.Inspector)

			location := pass.Program.Location
			elaboration := pass.Program.Elaboration
			report := pass.Report

			inspector.Preorder(
				elementFilter,
				func(element ast.Element) {
					memberExpression, ok := element.(*ast.MemberExpression)
					if !ok {
						return
					}

					memberInfo, _ := elaboration.MemberExpressionMemberInfo(memberExpression)
					member := memberInfo.Member
					if member == nil {
						return
					}

					docStringMatch := docStringDeprecationWarningPattern.FindStringSubmatch(member.DocString)
					if docStringMatch == nil {
						return
					}

					memberName := memberInfo.Member.Identifier.Identifier

					identifierRange := ast.NewRangeFromPositioned(nil, memberExpression.Identifier)

					var suggestedFixes []analysis.SuggestedFix

					replacement := memberReplacement(memberInfo)
					if replacement != "" {
						suggestedFix := analysis.SuggestedFix{
							Message: "replace",
							TextEdits: []analysis.TextEdit{
								{
									Replacement: replacement,
									Range:       identifierRange,
								},
							},
						}
						suggestedFixes = append(suggestedFixes, suggestedFix)
					}

					report(
						analysis.Diagnostic{
							Location: location,
							Range:    identifierRange,
							Category: DeprecatedCategory,
							Message: fmt.Sprintf(
								"%s '%s' is deprecated",
								member.DeclarationKind.Name(),
								memberName,
							),
							SecondaryMessage: docStringMatch[1],
							SuggestedFixes:   suggestedFixes,
						},
					)
				},
			)

			return nil
		},
	}
})()

var NumberFunctionArgumentAnalyzer = (func() *analysis.Analyzer {

	elementFilter := []ast.Element{
		(*ast.IntegerExpression)(nil),
		(*ast.FixedPointExpression)(nil),
	}

	return &analysis.Analyzer{
		Description: "Detects redundant uses of number conversion functions.",
		Requires: []*analysis.Analyzer{
			analysis.InspectorAnalyzer,
		},
		Run: func(pass *analysis.Pass) interface{} {
			inspector := pass.ResultOf[analysis.InspectorAnalyzer].(*ast.Inspector)

			location := pass.Program.Location
			elaboration := pass.Program.Elaboration
			report := pass.Report

			inspector.Preorder(
				elementFilter,
				func(element ast.Element) {

					var diagnostic *analysis.Diagnostic

					switch expr := element.(type) {
					case *ast.IntegerExpression:
						argumentData := elaboration.NumberConversionArgumentTypes(expr)
						if argumentData.Type == nil {
							return
						}
						diagnostic = suggestIntegerLiteralConversionReplacement(
							expr,
							location,
							argumentData.Type,
							argumentData.Range,
						)

					case *ast.FixedPointExpression:
						argumentData := elaboration.NumberConversionArgumentTypes(expr)
						if argumentData.Type == nil {
							return
						}
						diagnostic = suggestFixedPointLiteralConversionReplacement(
							expr,
							location,
							argumentData.Type,
							argumentData.Range,
						)

					default:
						return
					}

					if diagnostic != nil {
						report(*diagnostic)
					}
				},
			)

			return nil
		},
	}
})()

var RedundantCastAnalyzer = (func() *analysis.Analyzer {

	elementFilter := []ast.Element{
		(*ast.CastingExpression)(nil),
	}

	return &analysis.Analyzer{
		Description: "Detects unnecessary cast expressions",
		Requires: []*analysis.Analyzer{
			analysis.InspectorAnalyzer,
		},
		Run: func(pass *analysis.Pass) interface{} {
			inspector := pass.ResultOf[analysis.InspectorAnalyzer].(*ast.Inspector)

			location := pass.Program.Location
			elaboration := pass.Program.Elaboration
			report := pass.Report

			inspector.Preorder(
				elementFilter,
				func(element ast.Element) {

					castingExpression, ok := element.(*ast.CastingExpression)
					if !ok {
						return
					}

					redundantType := elaboration.StaticCastTypes(castingExpression)
					if redundantType.ExprActualType != nil && isRedundantCast(
						castingExpression.Expression,
						redundantType.ExprActualType,
						redundantType.TargetType,
						redundantType.ExpectedType,
					) {
						report(
							analysis.Diagnostic{
								Location: location,
								Range:    ast.NewRangeFromPositioned(nil, castingExpression.TypeAnnotation),
								Category: UnnecessaryCastCategory,
								Message:  fmt.Sprintf("cast to `%s` is redundant", redundantType.TargetType),
							},
						)
						return
					}

					alwaysSucceedingTypes := elaboration.RuntimeCastTypes(castingExpression)
					if alwaysSucceedingTypes.Left != nil &&
						sema.IsSubType(alwaysSucceedingTypes.Left, alwaysSucceedingTypes.Right) {

						switch castingExpression.Operation {
						case ast.OperationFailableCast:
							report(
								analysis.Diagnostic{
									Location: location,
									Range:    ast.NewRangeFromPositioned(nil, castingExpression),
									Category: UnnecessaryCastCategory,
									Message: fmt.Sprintf("failable cast ('%s') from `%s` to `%s` always succeeds",
										ast.OperationFailableCast.Symbol(),
										alwaysSucceedingTypes.Left,
										alwaysSucceedingTypes.Right),
								},
							)

						case ast.OperationForceCast:
							report(
								analysis.Diagnostic{
									Location: location,
									Range:    ast.NewRangeFromPositioned(nil, castingExpression),
									Category: UnnecessaryCastCategory,
									Message: fmt.Sprintf("force cast ('%s') from `%s` to `%s` always succeeds",
										ast.OperationForceCast.Symbol(),
										alwaysSucceedingTypes.Left,
										alwaysSucceedingTypes.Right),
								},
							)

						default:
							panic(errors.NewUnreachableError())
						}
					}
				},
			)

			return nil
		},
	}
})()

var ReferenceOperatorAnalyzer = (func() *analysis.Analyzer {

	elementFilter := []ast.Element{
		(*ast.ReferenceExpression)(nil),
	}

	invalidOperatorRegexp := regexp.MustCompile(`.*\bas[?!].*`)

	return &analysis.Analyzer{
		Description: "Detects invalid operators in reference expressions. These will get rejected in a future release.",
		Requires: []*analysis.Analyzer{
			analysis.InspectorAnalyzer,
		},
		Run: func(pass *analysis.Pass) interface{} {
			inspector := pass.ResultOf[analysis.InspectorAnalyzer].(*ast.Inspector)

			location := pass.Program.Location
			code := pass.Program.Code
			report := pass.Report

			inspector.Preorder(
				elementFilter,
				func(element ast.Element) {

					referenceExpression, ok := element.(*ast.ReferenceExpression)
					if !ok {
						return
					}

					startOffset := referenceExpression.Expression.EndPosition(nil).Offset + 1
					endOffset := referenceExpression.Type.StartPosition().Offset - 1

					if !invalidOperatorRegexp.Match(code[startOffset:endOffset]) {
						return
					}

					report(
						analysis.Diagnostic{
							Location: location,
							Range:    ast.NewRangeFromPositioned(nil, element),
							Category: UpdateCategory,
							Message:  "incorrect reference operator used",
							SecondaryMessage: fmt.Sprintf(
								"use the '%s' operator",
								ast.OperationCast.Symbol(),
							),
						},
					)
				},
			)

			return nil
		},
	}
})()

var UnnecessaryForceAnalyzer = (func() *analysis.Analyzer {

	elementFilter := []ast.Element{
		(*ast.ForceExpression)(nil),
	}

	return &analysis.Analyzer{
		Description: "Detects unnecessary uses of the force operator",
		Requires: []*analysis.Analyzer{
			analysis.InspectorAnalyzer,
		},
		Run: func(pass *analysis.Pass) interface{} {
			inspector := pass.ResultOf[analysis.InspectorAnalyzer].(*ast.Inspector)

			location := pass.Program.Location
			elaboration := pass.Program.Elaboration
			report := pass.Report

			inspector.Preorder(
				elementFilter,
				func(element ast.Element) {

					forceExpression, ok := element.(*ast.ForceExpression)
					if !ok {
						return
					}

					valueType := elaboration.ForceExpressionType(forceExpression)
					if valueType == nil {
						return
					}

					_, ok = valueType.(*sema.OptionalType)
					if !ok {
						report(
							analysis.Diagnostic{
								Location: location,
								Range:    ast.NewRangeFromPositioned(nil, element),
								Category: RemovalCategory,
								Message:  "unnecessary force operator",
							},
						)
					}
				},
			)

			return nil
		},
	}
})()