diff --git a/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectExtractor.kt b/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectExtractor.kt
index 8d2fd04886b9..f72bf31ee77b 100644
--- a/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectExtractor.kt
+++ b/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectExtractor.kt
@@ -114,15 +114,16 @@ object ParameterObjectExtractor {
                                    declaration: PsiVariable,
                                    referencesToDeclaration: List<PsiReferenceExpression>): List<TemplateField> {
     val file = introducedClass.containingFile
-    val classReference = (declaration.initializer as? PsiNewExpression)?.classReference?.element ?: throw IllegalStateException()
-    val variableName = declaration.nameIdentifier ?: throw IllegalStateException()
+    val classReference = (declaration.initializer as? PsiNewExpression)?.classReference?.referenceNameElement ?: throw IllegalStateException()
     val constructorIdentifiers = introducedClass.constructors.mapNotNull { method -> method.nameIdentifier }
-    val typeIdentifiersToUpdate = listOfNotNull(declaration.typeElement, introducedClass.nameIdentifier) + constructorIdentifiers
+    val declarationTypeIdentifier = declaration.typeElement?.innermostComponentReferenceElement?.referenceNameElement
+    val typeIdentifiersToUpdate = listOfNotNull(declarationTypeIdentifier, introducedClass.nameIdentifier) + constructorIdentifiers
     val typeNameField = TemplateField(
       classReference.textRange,
       typeIdentifiersToUpdate.map(PsiElement::getTextRange),
       validator = { variableRange -> InplaceExtractUtils.checkClassReference(editor, file, variableRange) }
     )
+    val variableName = declaration.nameIdentifier ?: throw IllegalStateException()
     val variableNameField = TemplateField(
       variableName.textRange,
       referencesToDeclaration.map(PsiElement::getTextRange),
diff --git a/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectUtils.kt b/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectUtils.kt
index 90a10d336e2b..171381d9ee9e 100644
--- a/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectUtils.kt
+++ b/java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/parameterObject/ParameterObjectUtils.kt
@@ -1,20 +1,27 @@
 // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.refactoring.extractMethod.newImpl.parameterObject
 
+import com.intellij.codeInsight.daemon.impl.analysis.HighlightingFeature
 import com.intellij.psi.*
 import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.PsiUtil
-import com.siyeh.ig.psiutils.TypeUtils
 
 object ParameterObjectUtils {
 
   fun createDeclaration(introducedClass: PsiClass): PsiDeclarationStatement {
-    val parameters = introducedClass.constructors.first().parameterList.parameters.map(PsiParameter::getName).joinToString(separator = ",")
-    val initializer = "new ${introducedClass.name}($parameters)"
     val factory = PsiElementFactory.getInstance(introducedClass.project)
-    val expression = factory.createExpressionFromText(initializer, introducedClass)
-    return factory.createVariableDeclarationStatement("result", TypeUtils.getType(introducedClass), expression)
+    val typeParameters = introducedClass.typeParameters.map(factory::createType).toTypedArray()
+    val type = factory.createType(introducedClass, *typeParameters)
+    val typeElement = if (HighlightingFeature.DIAMOND_TYPES.isAvailable(introducedClass) && typeParameters.isNotEmpty()) {
+      "${type.name}<>"
+    } else {
+      type.canonicalText
+    }
+    val constructor = introducedClass.constructors.first()
+    val parameters = constructor.parameterList.parameters.joinToString(separator = ",") { it.name }
+    val expression = factory.createExpressionFromText("new $typeElement($parameters)", introducedClass)
+    return factory.createVariableDeclarationStatement("result", type, expression)
   }
 
   fun findAffectedReferences(variables: List<PsiVariable>, startingElement: PsiElement?): List<PsiReferenceExpression> {