diff --git a/server/src/analyzer/binder.ts b/server/src/analyzer/binder.ts
index e0e94d5ae..22a05ab9b 100644
--- a/server/src/analyzer/binder.ts
+++ b/server/src/analyzer/binder.ts
@@ -289,7 +289,6 @@ export class Binder extends ParseTreeWalker {
     }
 
     visitFunction(node: FunctionNode): boolean {
-
         const symbol = this._bindNameToScope(this._currentScope, node.name.nameToken.value);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, true);
         const declarationType = containingClassNode ?
@@ -384,7 +383,7 @@ export class Binder extends ParseTreeWalker {
                             });
                         }
 
-                        this._createAssignmentTargetFlowNodes(paramNode.name);
+                        this._createFlowAssignment(paramNode.name);
                     }
                 });
 
@@ -442,7 +441,7 @@ export class Binder extends ParseTreeWalker {
                             });
                         }
 
-                        this._createAssignmentTargetFlowNodes(paramNode.name);
+                        this._createFlowAssignment(paramNode.name);
                         this.walk(paramNode.name);
                     }
                 });
diff --git a/server/src/analyzer/typeEvaluator.ts b/server/src/analyzer/typeEvaluator.ts
index a02de4bd8..688f862a3 100644
--- a/server/src/analyzer/typeEvaluator.ts
+++ b/server/src/analyzer/typeEvaluator.ts
@@ -219,8 +219,6 @@ export interface TypeEvaluator {
     getTypeOfImportAsTarget: (node: ImportAsNode) => Type | undefined;
     getTypeOfImportFromTarget: (node: ImportFromAsNode) => Type | undefined;
 
-    getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
-
     getDeclaredTypeForExpression: (expression: ExpressionNode) => Type | undefined;
 
     isAnnotationLiteralValue: (node: StringListNode) => boolean;
@@ -230,10 +228,6 @@ export interface TypeEvaluator {
 
     transformTypeForPossibleEnumClass: (node: NameNode, typeOfExpr: Type) => Type;
 
-    assignTypeToNameNode: (nameNode: NameNode, type: Type, srcExpression?: ParseNode) => void;
-    assignTypeToExpression: (target: ExpressionNode, type: Type, srcExpr?: ExpressionNode,
-        targetOfInterest?: ExpressionNode) => Type | undefined;
-
     updateExpressionTypeForNode: (node: ParseNode, exprType: Type) => void;
 
     addError: (message: string, node: ParseNode) => Diagnostic | undefined;
@@ -245,7 +239,6 @@ export interface TypeEvaluator {
 }
 
 export function createTypeEvaluator(importLookup: ImportLookup): TypeEvaluator {
-
     let isSpeculativeMode = false;
     const typeResolutionRecursionMap = new Map<number, true>();
 
@@ -253,14 +246,6 @@ export function createTypeEvaluator(importLookup: ImportLookup): TypeEvaluator {
         return getTypeOfExpression(node, usage, flags).type;
     }
 
-    function getTypeNoCache(node: ExpressionNode, usage: EvaluatorUsage = { method: 'get' }, flags = EvaluatorFlags.None): Type {
-        let type: Type | undefined;
-        useSpeculativeMode(() => {
-            type = getTypeOfExpression(node, usage, flags).type;
-        });
-        return type!;
-    }
-
     function getTypeOfAnnotation(node: ExpressionNode): Type {
         const fileInfo = getFileInfo(node);
 
@@ -390,9 +375,7 @@ export function createTypeEvaluator(importLookup: ImportLookup): TypeEvaluator {
             }
 
             case ParseNodeType.MemberAccess: {
-                // Get the base type but do so speculative because we're going to call again
-                // with a 'set' usage type below, and we don't want to skip that logic.
-                const baseType = getTypeNoCache(expression.leftExpression);
+                const baseType = getType(expression.leftExpression);
                 let classMemberInfo: ClassMember | undefined;
 
                 if (baseType.category === TypeCategory.Object) {
@@ -7115,14 +7098,11 @@ export function createTypeEvaluator(importLookup: ImportLookup): TypeEvaluator {
         getTypeOfWithItemTarget,
         getTypeOfImportAsTarget,
         getTypeOfImportFromTarget,
-        getTypingType,
         getDeclaredTypeForExpression,
         isAnnotationLiteralValue,
         isAfterNodeReachable,
         isNodeReachable,
         transformTypeForPossibleEnumClass,
-        assignTypeToNameNode,
-        assignTypeToExpression,
         updateExpressionTypeForNode,
         addError,
         addWarning,