_fe_analyzer_shared/lib/src/type_inference/variable_bindings.dart - third_party/dart-pkg - Git at Google

 // Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 import 'type_analyzer.dart';

 /// Data structure for tracking declared pattern variables.
 ///
 /// To analyze a single `case pattern when guard`:
 /// 1. Invoke [casePatternStart].
 /// 2. Invoke zero or more [add].
 /// 3. Invoke [casePatternFinish], get the set of variables `VS`.
 /// 4. Use `VS` to analyze the guard.
 ///
 /// To analyze a group of `case` members of a `switch` statement, sharing
 /// the same body, and so having the shared set of pattern variables:
 /// 1. Invoke [switchStatementSharedCaseScopeStart].
 /// 2. Analyze individual `case pattern when guard` clauses.
 /// 3. Invoke [switchStatementSharedCaseScopeEmpty] if there are labels,
 ///    or a `default` member.
 /// 4. Invoke [switchStatementSharedCaseScopeFinish] to get the set of
 ///    variables `VS`, and use it to analyze the shared body.
 abstract class VariableBinder<Node extends Object, Variable extends Object> {
   /// The interface for reporting error conditions up to the client.
   final VariableBinderErrors<Node, Variable>? errors;

   /// The stack of variable sets, starting with an empty one on
   /// [casePatternStart], or [logicalOrPatternStart].
   List<Map<String, Variable>> _variables = [];

   /// The stack of variable sets for potentially nested (e.g. `switch` in
   /// a closure in a `when` clause) groups of `case` members of a `switch`
   /// statement.
   List<_SharedCaseScope<Variable>> _sharedCaseScopes = [];

   VariableBinder({
     required this.errors,
   });

   /// Updates the set of bindings to account for the presence of a variable
   /// pattern.  [name] is the name of the variable, [variable] is the object
   /// that represents it in the client.
   bool add(String name, Variable variable) {
     Variable? existing = _variables.last[name];
     if (existing == null) {
       _variables.last[name] = variable;
       return true;
     } else {
       errors?.duplicateVariablePattern(
         name: name,
         original: existing,
         duplicate: variable,
       );
       return false;
     }
   }

   /// Should be invoked after visiting a `case pattern` structure.  Returns
   /// all the accumulated variables (individual and joined).
   ///
   /// If [sharedCaseScopeKey] is provided, it expected to be the same as
   /// the key of the last shared case scope, and the resulting set will be
   /// joined with the current shared case scope.
   Map<String, Variable> casePatternFinish({
     Object? sharedCaseScopeKey,
   }) {
     Map<String, Variable> variables = _variables.removeLast();

     if (sharedCaseScopeKey != null) {
       _SharedCaseScope<Variable> sharedScope = _sharedCaseScopes.last;
       assert(sharedScope.key == sharedCaseScopeKey);
       sharedScope.addAll(variables);
     }

     return variables;
   }

   /// Notifies that are new `case pattern` structure is about to be visited.
   void casePatternStart() {
     _variables.add({});
   }

   /// Notifies that this instance is about to be discarded.
   void finish() {
     assert(_variables.isEmpty);
     assert(_sharedCaseScopes.isEmpty);
   }

   /// Returns a new variable that is a join of [components].
   Variable joinPatternVariables({
     required Object key,
     required List<Variable> components,
     required JoinedPatternVariableInconsistency inconsistency,
   });

   /// Updates the binder after visiting a logical-or pattern, joins variables
   /// from them.  If some variables are in one side of the pattern, but not
   /// in another, they are still joined, but marked as not consistent.
   void logicalOrPatternFinish(Node node) {
     Map<String, Variable> right = _variables.removeLast();
     Map<String, Variable> left = _variables.removeLast();
     for (MapEntry<String, Variable> leftEntry in left.entries) {
       String name = leftEntry.key;
       Variable leftVariable = leftEntry.value;
       Variable? rightVariable = right.remove(name);
       if (rightVariable != null) {
         add(
           name,
           joinPatternVariables(
             key: node,
             components: [leftVariable, rightVariable],
             inconsistency: JoinedPatternVariableInconsistency.none,
           ),
         );
       } else {
         errors?.logicalOrPatternBranchMissingVariable(
           node: node,
           hasInLeft: true,
           name: name,
           variable: leftVariable,
         );
         add(
           name,
           joinPatternVariables(
             key: node,
             components: [leftVariable],
             inconsistency: JoinedPatternVariableInconsistency.logicalOr,
           ),
         );
       }
     }
     for (MapEntry<String, Variable> rightEntry in right.entries) {
       String name = rightEntry.key;
       Variable rightVariable = rightEntry.value;
       errors?.logicalOrPatternBranchMissingVariable(
         node: node,
         hasInLeft: false,
         name: name,
         variable: rightVariable,
       );
       add(
         name,
         joinPatternVariables(
           key: node,
           components: [rightVariable],
           inconsistency: JoinedPatternVariableInconsistency.logicalOr,
         ),
       );
     }
   }

   /// Notifies that the LHS of a logical-or pattern was visited, and the RHS
   /// is about to be visited.
   void logicalOrPatternFinishLeft() {
     _variables.add({});
   }

   /// Notifies that we are about to start visiting a logical-or pattern.
   void logicalOrPatternStart() {
     _variables.add({});
   }

   /// Notifies that the `default` case head, or a label, was found, so that
   /// all the variables of the current shared case scope are not consistent.
   void switchStatementSharedCaseScopeEmpty(Object key) {
     _SharedCaseScope<Variable> sharedScope = _sharedCaseScopes.last;
     assert(sharedScope.key == key);
     sharedScope.hasLabel = true;
     sharedScope.addAll({});
   }

   /// Notifies that computing of the shared case scope was finished, returns
   /// the joined set of variables.  The variables have not been checked to
   /// have the same types (because we have not done inference, so we don't
   /// know types for many of them), so some of them might become not
   /// consistent later.
   Map<String, Variable> switchStatementSharedCaseScopeFinish(Object key) {
     assert(_variables.isEmpty);
     _SharedCaseScope<Variable> sharedScope = _sharedCaseScopes.removeLast();
     assert(sharedScope.key == key);

     Map<String, Variable> result = {};
     for (MapEntry<String, _SharedCaseScopeVariable<Variable>> entry
         in sharedScope.variables.entries) {
       _SharedCaseScopeVariable<Variable> sharedVariable = entry.value;
       List<Variable> variables = sharedVariable.variables;
       if (sharedVariable.allCases && variables.length == 1) {
         result[entry.key] = variables[0];
       } else {
         result[entry.key] = joinPatternVariables(
           key: key,
           components: variables,
           inconsistency: sharedVariable.allCases
               ? JoinedPatternVariableInconsistency.none
               : sharedScope.hasLabel
                   ? JoinedPatternVariableInconsistency.sharedCaseHasLabel
                   : JoinedPatternVariableInconsistency.sharedCaseAbsent,
         );
       }
     }
     return result;
   }

   /// Notifies that computing new shared case scope should be started.
   void switchStatementSharedCaseScopeStart(Object key) {
     assert(_variables.isEmpty);
     _sharedCaseScopes.add(
       new _SharedCaseScope(key),
     );
   }
 }

 /// Interface used by the [VariableBinder] logic to report error conditions
 /// up to the client during the "pre-visit" phase of type analysis.
 abstract class VariableBinderErrors<Node extends Object,
     Variable extends Object> extends TypeAnalyzerErrorsBase {
   /// Called when a pattern attempts to declare the variable [duplicate] that
   /// has the same [name] as the [original] variable.
   void duplicateVariablePattern({
     required String name,
     required Variable original,
     required Variable duplicate,
   });

   /// Called when one of the branches has the [variable] with the [name], but
   /// the other branch does not.
   void logicalOrPatternBranchMissingVariable({
     required Node node,
     required bool hasInLeft,
     required String name,
     required Variable variable,
   });
 }

 class _SharedCaseScope<Variable extends Object> {
   final Object key;
   bool isEmpty = true;
   bool hasLabel = false;
   Map<String, _SharedCaseScopeVariable<Variable>> variables = {};

   _SharedCaseScope(this.key);

   /// Adds [newVariables] to [variables], marking absent variables as not
   /// consistent. If [isEmpty], just sets given variables as the starting set.
   void addAll(Map<String, Variable> newVariables) {
     if (isEmpty) {
       isEmpty = false;
       for (MapEntry<String, Variable> entry in newVariables.entries) {
         String name = entry.key;
         Variable variable = entry.value;
         _getVariable(name).variables.add(variable);
       }
     } else {
       for (MapEntry<String, _SharedCaseScopeVariable<Variable>> entry
           in variables.entries) {
         String name = entry.key;
         _SharedCaseScopeVariable<Variable> variable = entry.value;
         Variable? newVariable = newVariables[name];
         if (newVariable != null) {
           variable.variables.add(newVariable);
         } else {
           variable.allCases = false;
         }
       }
       for (MapEntry<String, Variable> newEntry in newVariables.entries) {
         String name = newEntry.key;
         Variable newVariable = newEntry.value;
         if (!variables.containsKey(name)) {
           _getVariable(name)
             ..allCases = false
             ..variables.add(newVariable);
         }
       }
     }
   }

   _SharedCaseScopeVariable _getVariable(String name) {
     return variables[name] ??= new _SharedCaseScopeVariable();
   }
 }

 class _SharedCaseScopeVariable<Variable extends Object> {
   bool allCases = true;
   final List<Variable> variables = [];
 }
	// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	import 'type_analyzer.dart';

	/// Data structure for tracking declared pattern variables.
	///
	/// To analyze a single `case pattern when guard`:
	/// 1. Invoke [casePatternStart].
	/// 2. Invoke zero or more [add].
	/// 3. Invoke [casePatternFinish], get the set of variables `VS`.
	/// 4. Use `VS` to analyze the guard.
	///
	/// To analyze a group of `case` members of a `switch` statement, sharing
	/// the same body, and so having the shared set of pattern variables:
	/// 1. Invoke [switchStatementSharedCaseScopeStart].
	/// 2. Analyze individual `case pattern when guard` clauses.
	/// 3. Invoke [switchStatementSharedCaseScopeEmpty] if there are labels,
	/// or a `default` member.
	/// 4. Invoke [switchStatementSharedCaseScopeFinish] to get the set of
	/// variables `VS`, and use it to analyze the shared body.
	abstract class VariableBinder<Node extends Object, Variable extends Object> {
	/// The interface for reporting error conditions up to the client.
	final VariableBinderErrors<Node, Variable>? errors;

	/// The stack of variable sets, starting with an empty one on
	/// [casePatternStart], or [logicalOrPatternStart].
	List<Map<String, Variable>> _variables = [];

	/// The stack of variable sets for potentially nested (e.g. `switch` in
	/// a closure in a `when` clause) groups of `case` members of a `switch`
	/// statement.
	List<_SharedCaseScope<Variable>> _sharedCaseScopes = [];

	VariableBinder({
	required this.errors,
	});

	/// Updates the set of bindings to account for the presence of a variable
	/// pattern. [name] is the name of the variable, [variable] is the object
	/// that represents it in the client.
	bool add(String name, Variable variable) {
	Variable? existing = _variables.last[name];
	if (existing == null) {
	_variables.last[name] = variable;
	return true;
	} else {
	errors?.duplicateVariablePattern(
	name: name,
	original: existing,
	duplicate: variable,
	);
	return false;
	}
	}

	/// Should be invoked after visiting a `case pattern` structure. Returns
	/// all the accumulated variables (individual and joined).
	///
	/// If [sharedCaseScopeKey] is provided, it expected to be the same as
	/// the key of the last shared case scope, and the resulting set will be
	/// joined with the current shared case scope.
	Map<String, Variable> casePatternFinish({
	Object? sharedCaseScopeKey,
	}) {
	Map<String, Variable> variables = _variables.removeLast();

	if (sharedCaseScopeKey != null) {
	_SharedCaseScope<Variable> sharedScope = _sharedCaseScopes.last;
	assert(sharedScope.key == sharedCaseScopeKey);
	sharedScope.addAll(variables);
	}

	return variables;
	}

	/// Notifies that are new `case pattern` structure is about to be visited.
	void casePatternStart() {
	_variables.add({});
	}

	/// Notifies that this instance is about to be discarded.
	void finish() {
	assert(_variables.isEmpty);
	assert(_sharedCaseScopes.isEmpty);
	}

	/// Returns a new variable that is a join of [components].
	Variable joinPatternVariables({
	required Object key,
	required List<Variable> components,
	required JoinedPatternVariableInconsistency inconsistency,
	});

	/// Updates the binder after visiting a logical-or pattern, joins variables
	/// from them. If some variables are in one side of the pattern, but not
	/// in another, they are still joined, but marked as not consistent.
	void logicalOrPatternFinish(Node node) {
	Map<String, Variable> right = _variables.removeLast();
	Map<String, Variable> left = _variables.removeLast();
	for (MapEntry<String, Variable> leftEntry in left.entries) {
	String name = leftEntry.key;
	Variable leftVariable = leftEntry.value;
	Variable? rightVariable = right.remove(name);
	if (rightVariable != null) {
	add(
	name,
	joinPatternVariables(
	key: node,
	components: [leftVariable, rightVariable],
	inconsistency: JoinedPatternVariableInconsistency.none,
	),
	);
	} else {
	errors?.logicalOrPatternBranchMissingVariable(
	node: node,
	hasInLeft: true,
	name: name,
	variable: leftVariable,
	);
	add(
	name,
	joinPatternVariables(
	key: node,
	components: [leftVariable],
	inconsistency: JoinedPatternVariableInconsistency.logicalOr,
	),
	);
	}
	}
	for (MapEntry<String, Variable> rightEntry in right.entries) {
	String name = rightEntry.key;
	Variable rightVariable = rightEntry.value;
	errors?.logicalOrPatternBranchMissingVariable(
	node: node,
	hasInLeft: false,
	name: name,
	variable: rightVariable,
	);
	add(
	name,
	joinPatternVariables(
	key: node,
	components: [rightVariable],
	inconsistency: JoinedPatternVariableInconsistency.logicalOr,
	),
	);
	}
	}

	/// Notifies that the LHS of a logical-or pattern was visited, and the RHS
	/// is about to be visited.
	void logicalOrPatternFinishLeft() {
	_variables.add({});
	}

	/// Notifies that we are about to start visiting a logical-or pattern.
	void logicalOrPatternStart() {
	_variables.add({});
	}

	/// Notifies that the `default` case head, or a label, was found, so that
	/// all the variables of the current shared case scope are not consistent.
	void switchStatementSharedCaseScopeEmpty(Object key) {
	_SharedCaseScope<Variable> sharedScope = _sharedCaseScopes.last;
	assert(sharedScope.key == key);
	sharedScope.hasLabel = true;
	sharedScope.addAll({});
	}

	/// Notifies that computing of the shared case scope was finished, returns
	/// the joined set of variables. The variables have not been checked to
	/// have the same types (because we have not done inference, so we don't
	/// know types for many of them), so some of them might become not
	/// consistent later.
	Map<String, Variable> switchStatementSharedCaseScopeFinish(Object key) {
	assert(_variables.isEmpty);
	_SharedCaseScope<Variable> sharedScope = _sharedCaseScopes.removeLast();
	assert(sharedScope.key == key);

	Map<String, Variable> result = {};
	for (MapEntry<String, _SharedCaseScopeVariable<Variable>> entry
	in sharedScope.variables.entries) {
	_SharedCaseScopeVariable<Variable> sharedVariable = entry.value;
	List<Variable> variables = sharedVariable.variables;
	if (sharedVariable.allCases && variables.length == 1) {
	result[entry.key] = variables[0];
	} else {
	result[entry.key] = joinPatternVariables(
	key: key,
	components: variables,
	inconsistency: sharedVariable.allCases
	? JoinedPatternVariableInconsistency.none
	: sharedScope.hasLabel
	? JoinedPatternVariableInconsistency.sharedCaseHasLabel
	: JoinedPatternVariableInconsistency.sharedCaseAbsent,
	);
	}
	}
	return result;
	}

	/// Notifies that computing new shared case scope should be started.
	void switchStatementSharedCaseScopeStart(Object key) {
	assert(_variables.isEmpty);
	_sharedCaseScopes.add(
	new _SharedCaseScope(key),
	);
	}
	}

	/// Interface used by the [VariableBinder] logic to report error conditions
	/// up to the client during the "pre-visit" phase of type analysis.
	abstract class VariableBinderErrors<Node extends Object,
	Variable extends Object> extends TypeAnalyzerErrorsBase {
	/// Called when a pattern attempts to declare the variable [duplicate] that
	/// has the same [name] as the [original] variable.
	void duplicateVariablePattern({
	required String name,
	required Variable original,
	required Variable duplicate,
	});

	/// Called when one of the branches has the [variable] with the [name], but
	/// the other branch does not.
	void logicalOrPatternBranchMissingVariable({
	required Node node,
	required bool hasInLeft,
	required String name,
	required Variable variable,
	});
	}

	class _SharedCaseScope<Variable extends Object> {
	final Object key;
	bool isEmpty = true;
	bool hasLabel = false;
	Map<String, _SharedCaseScopeVariable<Variable>> variables = {};

	_SharedCaseScope(this.key);

	/// Adds [newVariables] to [variables], marking absent variables as not
	/// consistent. If [isEmpty], just sets given variables as the starting set.
	void addAll(Map<String, Variable> newVariables) {
	if (isEmpty) {
	isEmpty = false;
	for (MapEntry<String, Variable> entry in newVariables.entries) {
	String name = entry.key;
	Variable variable = entry.value;
	_getVariable(name).variables.add(variable);
	}
	} else {
	for (MapEntry<String, _SharedCaseScopeVariable<Variable>> entry
	in variables.entries) {
	String name = entry.key;
	_SharedCaseScopeVariable<Variable> variable = entry.value;
	Variable? newVariable = newVariables[name];
	if (newVariable != null) {
	variable.variables.add(newVariable);
	} else {
	variable.allCases = false;
	}
	}
	for (MapEntry<String, Variable> newEntry in newVariables.entries) {
	String name = newEntry.key;
	Variable newVariable = newEntry.value;
	if (!variables.containsKey(name)) {
	_getVariable(name)
	..allCases = false
	..variables.add(newVariable);
	}
	}
	}
	}

	_SharedCaseScopeVariable _getVariable(String name) {
	return variables[name] ??= new _SharedCaseScopeVariable();
	}
	}

	class _SharedCaseScopeVariable<Variable extends Object> {
	bool allCases = true;
	final List<Variable> variables = [];
	}