*/
internal
object ConventionsResolutionProcessor {
    fun process(resolutionResult: ResolutionResult): Map<String, SoftwareTypeConventionResolutionResults> {
        val assignments = resolutionResult.assignments.groupBy { assignment ->
            getSoftwareType(assignment.lhs.receiverObject).function.simpleName
        }
        val additions = resolutionResult.additions.groupBy { addition ->

        is ErrorReason.ReadOnlyPropertyAssignment -> "assignment to read-only property '${errorReason.property.name}"
        ErrorReason.UnitAssignment -> "assignment of a Unit value"
        ErrorReason.UnresolvedAssignmentLhs -> "unresolved assignment target"
        ErrorReason.UnresolvedAssignmentRhs -> "unresolved assigned value"

}


interface AnalysisContextView : TypeRefContext {
    val schema: AnalysisSchema
    val imports: Map<String, FqName>
    val currentScopes: List<AnalysisScopeView>
    val assignments: List<AssignmentRecord>
}


class SchemaTypeRefContext(val schema: AnalysisSchema) : TypeRefContext {
    override fun resolveRef(dataTypeRef: DataTypeRef): DataType = when (dataTypeRef) {

func assignments1() {
	b, i, f, c, s := false, 1, 1.0, 1i, "foo"
	b = i /* ERRORx `cannot use .* in assignment` */
	i = f /* ERRORx `cannot use .* in assignment` */
	f = c /* ERRORx `cannot use .* in assignment` */
	c = s /* ERRORx `cannot use .* in assignment` */
	s = b /* ERRORx `cannot use .* in assignment` */

	v0, v1, v2 := 1 /* ERROR "assignment mismatch" */ , 2, 3, 4
	_, _, _ = v0, v1, v2

	b = true

	i += 1

        val referenceResolution = PropertyReferenceResolution(objectOrigin, it)
        when (val assignment = context.resolveAssignment(referenceResolution)) {
            is Assigned -> it to PropertyValueReflection(reflect(assignment.objectOrigin, context), assignment.assignmentMethod)
            else -> if (it.hasDefaultValue) {

 *
 * The order of generations is important as calls in later generations can override calls in earlier generations, but no the
 * other way around.
 * For instance, a property assignment can override a convention assignment, but a convention assignment cannot override a property assignment.
 */

        // TODO: optimize O(n) lookup
        softwareTypeRegistry.softwareTypeImplementations.find { it.softwareType == softwareTypeName }?.let { softwareType ->
            val assignments = buildList {
                softwareType.conventions.filterIsInstance<AssignmentRecordConvention>().forEach { it.apply(::add) }
            }
            val additions = buildList {

        propertyAccessResolver.doResolvePropertyAccessToAssignable(analysisContext, propertyAccess)

    override fun doResolveAssignment(context: AnalysisContext, assignment: Assignment): AssignmentRecord? =
        statementResolver.doResolveAssignment(context, assignment)

    override fun doResolveLocalValue(context: AnalysisContext, localValue: LocalValue) =
        statementResolver.doResolveLocalValue(context, localValue)

  @TestDataPath("$PROJECT_ROOT")
  public class Assignment {
    @Test
    public void testAllFilesPresentInAssignment() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment"), Pattern.compile("^(.+)\\.kt$"), null, true);
    }

    @Test

  @TestDataPath("$PROJECT_ROOT")
  public class Assignment {
    @Test
    public void testAllFilesPresentInAssignment() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/assignment"), Pattern.compile("^(.+)\\.kt$"), null, true);
    }

    @Test