@@ -58,84 +58,91 @@ int computeTypeVariableBuilderVariance(NominalVariableBuilder variable,
5858 typeArguments: List <TypeBuilder >? arguments
5959 ):
6060 assert (declaration != null );
61- if (declaration is NominalVariableBuilder ) {
62- if (declaration == variable) {
63- return Variance .covariant ;
64- } else {
65- return Variance .unrelated;
66- }
67- } else {
68- switch (declaration) {
69- case ClassBuilder ():
70- int result = Variance .unrelated;
71- if (arguments != null ) {
72- for (int i = 0 ; i < arguments.length; ++ i) {
73- result = Variance .meet (
74- result,
75- Variance .combine (
76- declaration.cls.typeParameters[i].variance,
77- computeTypeVariableBuilderVariance (
78- variable, arguments[i], libraryBuilder)));
79- }
61+ switch (declaration) {
62+ case ClassBuilder ():
63+ int result = Variance .unrelated;
64+ if (arguments != null ) {
65+ for (int i = 0 ; i < arguments.length; ++ i) {
66+ result = Variance .meet (
67+ result,
68+ Variance .combine (
69+ declaration.cls.typeParameters[i].variance,
70+ computeTypeVariableBuilderVariance (
71+ variable, arguments[i], libraryBuilder)));
8072 }
81- return result;
82- case TypeAliasBuilder ():
83- int result = Variance .unrelated;
84-
85- if (type.typeArguments != null ) {
86- for (int i = 0 ; i < type.typeArguments! .length; ++ i) {
87- const int visitMarker = - 2 ;
88-
89- int declarationTypeVariableVariance = declaration.varianceAt (i);
90- if (declarationTypeVariableVariance == pendingVariance) {
91- assert (! declaration.fromDill);
92- NominalVariableBuilder declarationTypeVariable =
93- declaration.typeVariables! [i];
94- declarationTypeVariable.variance = visitMarker;
95- int computedVariance = computeTypeVariableBuilderVariance (
96- declarationTypeVariable,
97- declaration.type,
98- libraryBuilder);
99- declarationTypeVariableVariance =
100- declarationTypeVariable.variance = computedVariance;
101- } else if (declarationTypeVariableVariance == visitMarker) {
102- assert (! declaration.fromDill);
103- NominalVariableBuilder declarationTypeVariable =
104- declaration.typeVariables! [i];
105- libraryBuilder.addProblem (
106- templateCyclicTypedef.withArguments (declaration.name),
107- declaration.charOffset,
108- declaration.name.length,
109- declaration.fileUri);
110- // Use [Variance.unrelated] for recovery. The type with the
111- // cyclic dependency will be replaced with an [InvalidType]
112- // elsewhere.
113- declarationTypeVariableVariance =
114- declarationTypeVariable.variance = Variance .unrelated;
115- }
116-
117- result = Variance .meet (
118- result,
119- Variance .combine (
120- computeTypeVariableBuilderVariance (
121- variable, type.typeArguments! [i], libraryBuilder),
122- declarationTypeVariableVariance));
73+ }
74+ return result;
75+ case TypeAliasBuilder ():
76+ int result = Variance .unrelated;
77+
78+ if (type.typeArguments != null ) {
79+ for (int i = 0 ; i < type.typeArguments! .length; ++ i) {
80+ const int visitMarker = - 2 ;
81+
82+ int declarationTypeVariableVariance = declaration.varianceAt (i);
83+ if (declarationTypeVariableVariance == pendingVariance) {
84+ assert (! declaration.fromDill);
85+ NominalVariableBuilder declarationTypeVariable =
86+ declaration.typeVariables! [i];
87+ declarationTypeVariable.variance = visitMarker;
88+ int computedVariance = computeTypeVariableBuilderVariance (
89+ declarationTypeVariable, declaration.type, libraryBuilder);
90+ declarationTypeVariableVariance =
91+ declarationTypeVariable.variance = computedVariance;
92+ } else if (declarationTypeVariableVariance == visitMarker) {
93+ assert (! declaration.fromDill);
94+ NominalVariableBuilder declarationTypeVariable =
95+ declaration.typeVariables! [i];
96+ libraryBuilder.addProblem (
97+ templateCyclicTypedef.withArguments (declaration.name),
98+ declaration.charOffset,
99+ declaration.name.length,
100+ declaration.fileUri);
101+ // Use [Variance.unrelated] for recovery. The type with the
102+ // cyclic dependency will be replaced with an [InvalidType]
103+ // elsewhere.
104+ declarationTypeVariableVariance =
105+ declarationTypeVariable.variance = Variance .unrelated;
123106 }
107+
108+ result = Variance .meet (
109+ result,
110+ Variance .combine (
111+ computeTypeVariableBuilderVariance (
112+ variable, type.typeArguments! [i], libraryBuilder),
113+ declarationTypeVariableVariance));
124114 }
125- return result;
126- case ExtensionTypeDeclarationBuilder ():
127- // TODO(johnniwinther): Handle this case.
128- case NominalVariableBuilder ():
129- case StructuralVariableBuilder ():
130- case ExtensionBuilder ():
131- case InvalidTypeDeclarationBuilder ():
132- case BuiltinTypeDeclarationBuilder ():
133- // TODO(johnniwinther): How should we handle this case?
134- case OmittedTypeDeclarationBuilder ():
135- case null :
136- }
137- return Variance .unrelated;
115+ }
116+ return result;
117+ case ExtensionTypeDeclarationBuilder ():
118+ int result = Variance .unrelated;
119+ if (arguments != null ) {
120+ for (int i = 0 ; i < arguments.length; ++ i) {
121+ result = Variance .meet (
122+ result,
123+ Variance .combine (
124+ declaration
125+ .extensionTypeDeclaration.typeParameters[i].variance,
126+ computeTypeVariableBuilderVariance (
127+ variable, arguments[i], libraryBuilder)));
128+ }
129+ }
130+ return result;
131+ case NominalVariableBuilder ():
132+ if (declaration == variable) {
133+ return Variance .covariant ;
134+ } else {
135+ return Variance .unrelated;
136+ }
137+ case StructuralVariableBuilder ():
138+ case ExtensionBuilder ():
139+ case InvalidTypeDeclarationBuilder ():
140+ case BuiltinTypeDeclarationBuilder ():
141+ // TODO(johnniwinther): How should we handle this case?
142+ case OmittedTypeDeclarationBuilder ():
143+ case null :
138144 }
145+ return Variance .unrelated;
139146 case FunctionTypeBuilder (
140147 : List <StructuralVariableBuilder >? typeVariables,
141148 : List <ParameterBuilder >? formals,
0 commit comments