remove un-use code

mindspore/core/ops/adam.h

@@ -40,7 +40,6 @@ class MS_CORE_API Adam : public PrimitiveC {
 };
 AbstractBasePtr AdamInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimAdamPtr = std::shared_ptr<Adam>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/add.h

@@ -38,7 +38,6 @@ class MS_CORE_API Add : public PrimitiveC {
 
 AbstractBasePtr AddInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                          const std::vector<AbstractBasePtr> &input_args);
-using PrimAddPtr = std::shared_ptr<Add>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/addn.h

@@ -34,7 +34,6 @@ class MS_CORE_API AddN : public PrimitiveC {
 };
 AbstractBasePtr AddNInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimAddNPtr = std::shared_ptr<AddN>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/apply_adagrad_d_a.h

@@ -44,7 +44,6 @@ class ApplyAdagradDA : public PrimitiveC {
 AbstractBasePtr ApplyAdagradDAInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                     const std::vector<AbstractBasePtr> &input_args);
 
-using PrimApplyAdagradDAPtr = std::shared_ptr<ApplyAdagradDA>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_APPLY_ADAGRAD_D_A_H_

mindspore/core/ops/apply_momentum.h

@@ -43,7 +43,6 @@ class MS_CORE_API ApplyMomentum : public PrimitiveC {
 };
 AbstractBasePtr ApplyMomentumInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimApplyMomentumPtr = std::shared_ptr<ApplyMomentum>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/arg_max.h

@@ -43,7 +43,6 @@ class MS_CORE_API ArgMax : public PrimitiveC {
 };
 AbstractBasePtr ArgMaxInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                             const std::vector<AbstractBasePtr> &input_args);
-using PrimArgMaxPtr = std::shared_ptr<ArgMax>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/asin.h

@@ -35,7 +35,6 @@ class MS_CORE_API Asin : public PrimitiveC {
 };
 AbstractBasePtr ASinInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimAsinPtr = std::shared_ptr<Asin>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/assert.h

@@ -37,7 +37,6 @@ class MS_CORE_API Assert : public PrimitiveC {
 
 AbstractBasePtr AssertInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                             const std::vector<AbstractBasePtr> &input_args);
-using PrimAssertPtr = std::shared_ptr<Assert>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/assign.h

@@ -34,7 +34,6 @@ class MS_CORE_API Assign : public PrimitiveC {
   void Init() {}
 };
 
-using PrimAssignPtr = std::shared_ptr<Assign>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/assign_add.h

@@ -35,7 +35,6 @@ class MS_CORE_API AssignAdd : public PrimitiveC {
 };
 AbstractBasePtr AssignAddInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                const std::vector<AbstractBasePtr> &input_args);
-using PrimAssignAddPtr = std::shared_ptr<AssignAdd>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/atan.h

@@ -36,7 +36,6 @@ class MS_CORE_API Atan : public PrimitiveC {
 };
 AbstractBasePtr ATanInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimAtanPtr = std::shared_ptr<Atan>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/audio_spectrogram.h

@@ -44,7 +44,6 @@ class MS_CORE_API AudioSpectrogram : public PrimitiveC {
 };
 AbstractBasePtr AudioSpectrogramInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                       const std::vector<AbstractBasePtr> &input_args);
-using PrimAudioSpectrogramPtr = std::shared_ptr<AudioSpectrogram>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/avg_pool.h

@@ -54,7 +54,6 @@ class MS_CORE_API AvgPool : public PrimitiveC {
 
 AbstractBasePtr AvgPoolInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimAvgPoolPtr = std::shared_ptr<AvgPool>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/avg_pool_3d.h

@@ -36,7 +36,6 @@ class MS_CORE_API AvgPool3D : public PrimitiveC {
 
 AbstractBasePtr AvgPool3DInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                const std::vector<AbstractBasePtr> &input_args);
-using PrimAvgPool3DPtr = std::shared_ptr<AvgPool3D>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/batch_matmul.h

@@ -37,7 +37,6 @@ class MS_CORE_API BatchMatmul : public PrimitiveC {
 };
 AbstractBasePtr BatchMatmulInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimBatchMatmulPtr = std::shared_ptr<BatchMatmul>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/batch_to_space.h

@@ -40,7 +40,6 @@ class MS_CORE_API BatchToSpace : public PrimitiveC {
 
 AbstractBasePtr BatchToSpaceInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                   const std::vector<AbstractBasePtr> &input_args);
-using PrimBatchToSpacePtr = std::shared_ptr<BatchToSpace>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/batch_to_space_nd.h

@@ -41,7 +41,6 @@ class MS_CORE_API BatchToSpaceND : public PrimitiveC {
 };
 AbstractBasePtr BatchToSpaceNDInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                     const std::vector<AbstractBasePtr> &input_args);
-using PrimBatchToSpaceNDPtr = std::shared_ptr<BatchToSpaceND>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/bias_add.h

@@ -40,7 +40,6 @@ class MS_CORE_API BiasAdd : public PrimitiveC {
 };
 AbstractBasePtr BiasAddInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimBiasAddPtr = std::shared_ptr<BiasAdd>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/binary_cross_entropy.h

@@ -39,7 +39,6 @@ class MS_CORE_API BinaryCrossEntropy : public PrimitiveC {
 };
 AbstractBasePtr BinaryCrossEntropyGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                             const std::vector<AbstractBasePtr> &input_args);
-using PrimBinaryCrossEntropyPtr = std::shared_ptr<BinaryCrossEntropy>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_BINARY_CROSS_ENTROPY_H_

mindspore/core/ops/broadcast_to.h

@@ -39,7 +39,6 @@ class MS_CORE_API BroadcastTo : public PrimitiveC {
 
 AbstractBasePtr BroadcastToInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimBroadcastToPtr = std::shared_ptr<BroadcastTo>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/cdist.h

@@ -38,7 +38,6 @@ class MS_CORE_API Cdist : public PrimitiveC {
 
 AbstractBasePtr CdistInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                            const std::vector<AbstractBasePtr> &input_args);
-using PrimCdistPtr = std::shared_ptr<Cdist>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/ceil.h

@@ -36,7 +36,6 @@ class MS_CORE_API Ceil : public PrimitiveC {
 
 AbstractBasePtr CeilInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimCeilPtr = std::shared_ptr<Ceil>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_CEIL_H_

mindspore/core/ops/concat.h

@@ -38,7 +38,6 @@ class MS_CORE_API Concat : public PrimitiveC {
 };
 AbstractBasePtr ConcatInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                             const std::vector<AbstractBasePtr> &input_args);
-using PrimConcatPtr = std::shared_ptr<Concat>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_CONCAT_H_

mindspore/core/ops/constant_of_shape.h

@@ -39,7 +39,6 @@ class MS_CORE_API ConstantOfShape : public PrimitiveC {
 
 AbstractBasePtr ConstantOfShapeInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                      const std::vector<AbstractBasePtr> &input_args);
-using PrimConstantOfShapePtr = std::shared_ptr<ConstantOfShape>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/conv2d.h

@@ -59,7 +59,6 @@ class MS_CORE_API Conv2D : public PrimitiveC {
 };
 AbstractBasePtr Conv2dInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                             const std::vector<AbstractBasePtr> &input_args);
-using PrimConv2dPtr = std::shared_ptr<Conv2D>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_CONV2D_H_

mindspore/core/ops/conv2d_transpose.h

@@ -68,7 +68,6 @@ class MS_CORE_API Conv2DTranspose : public PrimitiveC {
 };
 AbstractBasePtr Conv2DTransposeInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                      const std::vector<AbstractBasePtr> &input_args);
-using PrimConv2DTransposePtr = std::shared_ptr<Conv2DTranspose>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_CONV2D_TRANSPOSE_H_

mindspore/core/ops/crop_and_resize.h

@@ -37,7 +37,6 @@ class MS_CORE_API CropAndResize : public PrimitiveC {
   ResizeMethod get_method() const;
   float get_extrapolation_value() const;
 };
-using PrimCropAndResizePtr = std::shared_ptr<CropAndResize>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/ctc_loss_v2.h

@@ -39,7 +39,6 @@ class MS_CORE_API CTCLossV2 : public PrimitiveC {
 
 AbstractBasePtr CTCLossV2Infer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                const std::vector<AbstractBasePtr> &input_args);
-using PrimCTCLossV2Ptr = std::shared_ptr<CTCLossV2>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/ctcloss.h

@@ -33,7 +33,6 @@ class MS_CORE_API CTCLoss : public PrimitiveC {
 };
 AbstractBasePtr CTCLossInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimCTCLossPtr = std::shared_ptr<CTCLoss>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/custom.h

@@ -41,7 +41,6 @@ class MS_CORE_API Custom : public PrimitiveC {
   std::map<std::string, std::vector<uint8_t>> get_attr() const;
 };
 
-using PrimCustomPtr = std::shared_ptr<Custom>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/custom_extract_features.h

@@ -34,7 +34,6 @@ class MS_CORE_API CustomExtractFeatures : public PrimitiveC {
 };
 AbstractBasePtr CustomExtractFeaturesInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                            const std::vector<AbstractBasePtr> &input_args);
-using PrimCustomExtractFeaturesPtr = std::shared_ptr<CustomExtractFeatures>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/custom_normalize.h

@@ -35,7 +35,6 @@ class MS_CORE_API CustomNormalize : public PrimitiveC {
 
 AbstractBasePtr CustomNormalizeInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                      const std::vector<AbstractBasePtr> &input_args);
-using PrimCustomNormalizePtr = std::shared_ptr<CustomNormalize>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/custom_predict.h

@@ -39,7 +39,6 @@ class MS_CORE_API CustomPredict : public PrimitiveC {
 };
 AbstractBasePtr CustomPredictInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimCustomPredictPtr = std::shared_ptr<CustomPredict>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/depth_to_space.h

@@ -42,7 +42,6 @@ class MS_CORE_API DepthToSpace : public PrimitiveC {
 
 AbstractBasePtr DepthToSpaceInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                   const std::vector<AbstractBasePtr> &input_args);
-using PrimDepthToSpacePtr = std::shared_ptr<DepthToSpace>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/detection_post_process.h

@@ -64,7 +64,6 @@ class MS_CORE_API DetectionPostProcess : public PrimitiveC {
 };
 AbstractBasePtr DetectionPostProcessInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                           const std::vector<AbstractBasePtr> &input_args);
-using PrimDetectionPostProcessPtr = std::shared_ptr<DetectionPostProcess>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/diag.h

@@ -32,7 +32,6 @@ class MS_CORE_API Diag : public PrimitiveC {
 };
 AbstractBasePtr DiagInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimDiagPtr = std::shared_ptr<Diag>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/diag_part.h

@@ -32,7 +32,6 @@ class MS_CORE_API DiagPart : public PrimitiveC {
 };
 AbstractBasePtr DiagPartInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                               const std::vector<AbstractBasePtr> &input_args);
-using PrimDiagPartPtr = std::shared_ptr<DiagPart>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/div.h

@@ -36,7 +36,6 @@ class MS_CORE_API Div : public PrimitiveC {
 };
 AbstractBasePtr DivInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                          const std::vector<AbstractBasePtr> &input_args);
-using PrimDivPtr = std::shared_ptr<Div>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/dropout.h

@@ -37,7 +37,6 @@ class MS_CORE_API Dropout : public PrimitiveC {
 };
 AbstractBasePtr DropoutInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimDropoutPtr = std::shared_ptr<Dropout>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_DROPOUT_H_

mindspore/core/ops/dropout_do_mask.h

@@ -34,7 +34,6 @@ class MS_CORE_API DropoutDoMask : public PrimitiveC {
 };
 AbstractBasePtr DropoutDoMaskInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimDropoutDoMaskPtr = std::shared_ptr<DropoutDoMask>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/dropout_gen_mask.h

@@ -34,7 +34,6 @@ class MS_CORE_API DropoutGenMask : public PrimitiveC {
 };
 AbstractBasePtr DropoutGenMaskInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                     const std::vector<AbstractBasePtr> &input_args);
-using PrimDropoutGenMaskPtr = std::shared_ptr<DropoutGenMask>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/dtype.h

@@ -33,7 +33,6 @@ class MS_CORE_API DType : public PrimitiveC {
   MS_DECLARE_PARENT(DType, PrimitiveC);
   void Init() {}
 };
-using PrimDTypePtr = std::shared_ptr<DType>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/dynamic_broadcast_gradient_args.h

@@ -32,7 +32,6 @@ class MS_CORE_API DynamicBroadcastGradientArgs : public PrimitiveC {
 };
 AbstractBasePtr DynamicBroadcastGradientArgsInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                                   const std::vector<AbstractBasePtr> &input_args);
-using PrimDynamicBroadcastGradientArgsPtr = std::shared_ptr<DynamicBroadcastGradientArgs>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/embedding_lookup.h

@@ -38,7 +38,6 @@ class MS_CORE_API EmbeddingLookup : public PrimitiveC {
 };
 AbstractBasePtr EmbeddingLookupInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                      const std::vector<AbstractBasePtr> &input_args);
-using PrimEmbeddingLookupPtr = std::shared_ptr<EmbeddingLookup>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/equal.h

@@ -36,7 +36,6 @@ class MS_CORE_API Equal : public PrimitiveC {
 
 AbstractBasePtr EqualInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                            const std::vector<AbstractBasePtr> &input_args);
-using PrimEqualPtr = std::shared_ptr<Equal>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/erf.h

@@ -32,7 +32,6 @@ class MS_CORE_API Erf : public PrimitiveC {
   MS_DECLARE_PARENT(Erf, PrimitiveC);
 };
 
-using PrimErfPtr = std::shared_ptr<Erf>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/erfinv.h

@@ -34,7 +34,6 @@ class Erfinv : public PrimitiveC {
 
 AbstractBasePtr ErfinvInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                             const std::vector<AbstractBasePtr> &input_args);
-using PrimErfinvPtr = std::shared_ptr<Erfinv>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/exp.h

@@ -38,7 +38,6 @@ class MS_CORE_API Exp : public PrimitiveC {
 
 AbstractBasePtr ExpInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                          const std::vector<AbstractBasePtr> &input_args);
-using PrimExpPtr = std::shared_ptr<Exp>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fake_quant_with_min_max_vars.h

@@ -38,7 +38,6 @@ class MS_CORE_API FakeQuantWithMinMaxVars : public PrimitiveC {
 };
 AbstractBasePtr FakeQuantWithMinMaxVarsInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                              const std::vector<AbstractBasePtr> &input_args);
-using PrimFakeQuantWithMinMaxVarsPtr = std::shared_ptr<FakeQuantWithMinMaxVars>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fake_quant_with_min_max_vars_per_channel.h

@@ -42,7 +42,6 @@ class MS_CORE_API FakeQuantWithMinMaxVarsPerChannel : public PrimitiveC {
 AbstractBasePtr FakeQuantWithMinMaxVarsPerChannelInfer(const abstract::AnalysisEnginePtr &,
                                                        const PrimitivePtr &primitive,
                                                        const std::vector<AbstractBasePtr> &input_args);
-using PrimFakeQuantWithMinMaxVarsPerChannelPtr = std::shared_ptr<FakeQuantWithMinMaxVarsPerChannel>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fft_imag.h

@@ -36,7 +36,6 @@ class MS_CORE_API FftImag : public PrimitiveC {
 };
 AbstractBasePtr FftImagInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimFftImagPtr = std::shared_ptr<FftImag>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fft_real.h

@@ -36,7 +36,6 @@ class MS_CORE_API FftReal : public PrimitiveC {
 
 AbstractBasePtr FftRealInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimFftRealPtr = std::shared_ptr<FftReal>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fill.h

@@ -36,7 +36,6 @@ class MS_CORE_API Fill : public PrimitiveC {
 
 AbstractBasePtr FillInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimFillPtr = std::shared_ptr<Fill>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/flatten.h

@@ -35,7 +35,6 @@ class MS_CORE_API Flatten : public PrimitiveC {
 };
 AbstractBasePtr FlattenInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimFlattenPtr = std::shared_ptr<Flatten>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/floor.h

@@ -36,7 +36,6 @@ class MS_CORE_API Floor : public PrimitiveC {
 };
 AbstractBasePtr FloorInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                            const std::vector<AbstractBasePtr> &input_args);
-using PrimFLoorPtr = std::shared_ptr<Floor>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/add_fusion.h

@@ -38,7 +38,6 @@ class MS_CORE_API AddFusion : public Add {
 
 AbstractBasePtr AddFusionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                const std::vector<AbstractBasePtr> &input_args);
-using PrimAddFusionPtr = std::shared_ptr<AddFusion>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/avg_pool_fusion.h

@@ -43,7 +43,6 @@ class MS_CORE_API AvgPoolFusion : public AvgPool {
 
 AbstractBasePtr AvgPoolFusionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimAvgPoolFusionPtr = std::shared_ptr<AvgPoolFusion>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/full_connection.h

@@ -44,7 +44,6 @@ class MS_CORE_API FullConnection : public PrimitiveC {
 };
 AbstractBasePtr FullConnectionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                     const std::vector<AbstractBasePtr> &input_args);
-using PrimFullConnectionPtr = std::shared_ptr<FullConnection>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/layer_norm_fusion.h

@@ -39,7 +39,6 @@ class MS_CORE_API LayerNormFusion : public LayerNorm {
 
 AbstractBasePtr LayerNormFusionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                      const std::vector<AbstractBasePtr> &input_args);
-using PrimLayerNormFusionPtr = std::shared_ptr<LayerNormFusion>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/max_pool_fusion.h

@@ -43,7 +43,6 @@ class MS_CORE_API MaxPoolFusion : public MaxPool {
 
 AbstractBasePtr MaxPoolFusionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimMaxPoolFusionPtr = std::shared_ptr<MaxPoolFusion>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/reduce_fusion.h

@@ -45,7 +45,6 @@ class MS_CORE_API ReduceFusion : public Reduce {
 };
 AbstractBasePtr ReduceFusionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                   const std::vector<AbstractBasePtr> &input_args);
-using PrimReduceFusiuonPtr = std::shared_ptr<ReduceFusion>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/fusion/slice_fusion.h

@@ -38,7 +38,6 @@ class MS_CORE_API SliceFusion : public PrimitiveC {
 };
 AbstractBasePtr SliceFusionInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimSliceFusionPtr = std::shared_ptr<SliceFusion>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/gather.h

@@ -34,7 +34,6 @@ class MS_CORE_API Gather : public PrimitiveC {
   MS_DECLARE_PARENT(Gather, PrimitiveC);
   void Init() {}
 };
-using PrimGatherPtr = std::shared_ptr<Gather>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/gelu.h

@@ -33,7 +33,6 @@ class MS_CORE_API GeLU : public PrimitiveC {
   void Init() {}
 };
 
-using PrimGeLUPtr = std::shared_ptr<GeLU>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_GELU_H_

mindspore/core/ops/getnext.h

@@ -37,7 +37,6 @@ class MS_CORE_API GetNext : public PrimitiveC {
 };
 AbstractBasePtr GetNextInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimMulPtr = std::shared_ptr<GetNext>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_GETNEXT_H_

mindspore/core/ops/glu.h

@@ -36,7 +36,6 @@ class MS_CORE_API GLU : public PrimitiveC {
   int64_t get_axis() const;
 };
 
-using PrimGLUPtr = std::shared_ptr<GLU>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_GLU_H_

mindspore/core/ops/grad/avg_pool_3d_grad.h

@@ -38,7 +38,6 @@ class MS_CORE_API AvgPool3DGrad : public PrimitiveC {
 
 AbstractBasePtr AvgPool3DGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimAvgPool3DGradPtr = std::shared_ptr<AvgPool3DGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/avg_pool_grad.h

@@ -37,7 +37,6 @@ class MS_CORE_API AvgPoolGrad : public PoolGrad {
 
 AbstractBasePtr AvgPoolGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimAvgPoolGradPtr = std::shared_ptr<AvgPoolGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/batch_norm_grad.h

@@ -39,7 +39,6 @@ class MS_CORE_API BatchNormGrad : public PrimitiveC {
 
 AbstractBasePtr BatchNormGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimBatchNormGradPtr = std::shared_ptr<BatchNormGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/bias_add_grad.h

@@ -36,7 +36,6 @@ class MS_CORE_API BiasAddGrad : public PrimitiveC {
 };
 AbstractBasePtr BiasAddGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimBiasAddGradPtr = std::shared_ptr<BiasAddGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/binary_cross_entropy_grad.h

@@ -38,7 +38,6 @@ class MS_CORE_API BinaryCrossEntropyGrad : public PrimitiveC {
 };
 AbstractBasePtr BinaryCrossEntropyGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                             const std::vector<AbstractBasePtr> &input_args);
-using PrimBinaryCrossEntropyGradPtr = std::shared_ptr<BinaryCrossEntropyGrad>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_BINARY_CROSS_ENTROPY_GRAD_H_

mindspore/core/ops/grad/cdist_grad.h

@@ -38,7 +38,6 @@ class MS_CORE_API CdistGrad : public PrimitiveC {
 
 AbstractBasePtr CdistGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                const std::vector<AbstractBasePtr> &input_args);
-using PrimCdistGradPtr = std::shared_ptr<CdistGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/conv2d_backprop_filter.h

@@ -66,7 +66,6 @@ class MS_CORE_API Conv2DBackpropFilter : public PrimitiveC {
 };
 AbstractBasePtr Conv2DBackpropFilterInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                           const std::vector<AbstractBasePtr> &input_args);
-using PrimConv2DBackpropFilterPtr = std::shared_ptr<Conv2DBackpropFilter>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/conv2d_backprop_input.h

@@ -62,7 +62,6 @@ class MS_CORE_API Conv2DBackpropInput : public PrimitiveC {
 };
 AbstractBasePtr Conv2DBackpropInputInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                          const std::vector<AbstractBasePtr> &input_args);
-using PrimConv2DBackpropInputPtr = std::shared_ptr<Conv2DBackpropInput>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_CONV2D_BACKPROP_INPUT_H_

mindspore/core/ops/grad/dropout_grad.h

@@ -37,7 +37,6 @@ class MS_CORE_API DropoutGrad : public PrimitiveC {
 
 AbstractBasePtr DropoutGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimDropoutGradPtr = std::shared_ptr<DropoutGrad>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_DROPOUT_GRAD_H_

mindspore/core/ops/grad/group_conv2d_grad_input.h

@@ -67,7 +67,6 @@ class MS_CORE_API GroupConv2DGradInput : public PrimitiveC {
 };
 AbstractBasePtr GroupConv2DGradInputInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                           const std::vector<AbstractBasePtr> &input_args);
-using PrimGroupConv2DGradInputPtr = std::shared_ptr<GroupConv2DGradInput>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/hshrink_grad.h

@@ -34,7 +34,6 @@ class MS_CORE_API HShrinkGrad : public PrimitiveC {
 
 AbstractBasePtr HShrinkGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimHShrinkGradPtr = std::shared_ptr<HShrinkGrad>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_HSHRINK_GRAD_H_

mindspore/core/ops/grad/hsigmoid_grad.h

@@ -37,7 +37,6 @@ class MS_CORE_API HSigmoidGrad : public PrimitiveC {
 
 AbstractBasePtr HSigmoidGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                   const std::vector<AbstractBasePtr> &input_args);
-using PrimHSigmoidGradPtr = std::shared_ptr<HSigmoidGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/layer_norm_grad.h

@@ -42,7 +42,6 @@ class MS_CORE_API LayerNormGrad : public PrimitiveC {
 
 AbstractBasePtr LayerNormGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                    const std::vector<AbstractBasePtr> &input_args);
-using PrimLayerNormGradPtr = std::shared_ptr<LayerNormGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/lstm_grad.h

@@ -57,7 +57,6 @@ class MS_CORE_API LSTMGrad : public PrimitiveC {
 };
 AbstractBasePtr LstmGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                               const std::vector<AbstractBasePtr> &input_args);
-using PrimLstmGradPtr = std::shared_ptr<LSTMGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/max_pool_grad.h

@@ -36,7 +36,6 @@ class MS_CORE_API MaxPoolGrad : public PoolGrad {
 };
 
 AbstractBasePtr MaxPoolGradInfer(const std::vector<AbstractBasePtr> &input_args);
-using PrimMaxPoolGradPtr = std::shared_ptr<MaxPoolGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/mul_grad.h

@@ -32,7 +32,6 @@ class MS_CORE_API MulGrad : public PrimitiveC {
   void Init() {}
 };
 
-using PrimMulGradPtr = std::shared_ptr<MulGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/relu_grad.h

@@ -34,7 +34,6 @@ class MS_CORE_API ReLUGrad : public PrimitiveC {
   MS_DECLARE_PARENT(ReLUGrad, PrimitiveC);
   void Init() {}
 };
-using PrimReLUGradPtr = std::shared_ptr<ReLUGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/relu_grad_v2.h

@@ -34,7 +34,6 @@ class MS_CORE_API ReLUGradV2 : public PrimitiveC {
   MS_DECLARE_PARENT(ReLUGradV2, PrimitiveC);
   void Init() {}
 };
-using PrimReLUGradV2Ptr = std::shared_ptr<ReLUGradV2>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/resize_grad.h

@@ -39,7 +39,6 @@ class MS_CORE_API ResizeGrad : public PrimitiveC {
 
 AbstractBasePtr ResizeGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                 const std::vector<AbstractBasePtr> &input_args);
-using PrimResizeGradPtr = std::shared_ptr<ResizeGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/sigmoid_cross_entropy_with_logits_grad.h

@@ -39,7 +39,6 @@ class MS_CORE_API SigmoidCrossEntropyWithLogitsGrad : public PrimitiveC {
 AbstractBasePtr SigmoidCrossEntropyWithLogitsGradInfer(const abstract::AnalysisEnginePtr &,
                                                        const PrimitivePtr &primitive,
                                                        const std::vector<AbstractBasePtr> &input_args);
-using PrimSigmoidCrossEntropyWithLogitsGradPtr = std::shared_ptr<SigmoidCrossEntropyWithLogitsGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/grad/smooth_l1_loss_grad.h

@@ -38,7 +38,6 @@ class MS_CORE_API SmoothL1LossGrad : public PrimitiveC {
 };
 AbstractBasePtr SmoothL1LossGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                       const std::vector<AbstractBasePtr> &input_args);
-using PrimSmoothL1LossGradPtr = std::shared_ptr<SmoothL1LossGrad>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_SMOOTH_L1_LOSS_GRAD_H_

mindspore/core/ops/grad/soft_margin_loss_grad.h

@@ -37,7 +37,6 @@ class MS_CORE_API SoftMarginLossGrad : public PrimitiveC {
 
 AbstractBasePtr SoftMarginLossGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                         const std::vector<AbstractBasePtr> &input_args);
-using PrimSoftMarginLossGradPtr = std::shared_ptr<SoftMarginLossGrad>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_SOFT_MARGIN_LOSS_GRAD_H_

mindspore/core/ops/grad/soft_shrink_grad.h

@@ -36,7 +36,6 @@ class MS_CORE_API SoftShrinkGrad : public PrimitiveC {
 };
 AbstractBasePtr SoftShrinkGradInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                     const std::vector<AbstractBasePtr> &input_args);
-using PrimSoftShrinkGradPtr = std::shared_ptr<SoftShrinkGrad>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_SOFTSHRINK_GRAD_H_

mindspore/core/ops/grad/sub_grad.h

@@ -32,7 +32,6 @@ class MS_CORE_API SubGrad : public PrimitiveC {
   void Init() {}
 };
 
-using PrimSubGradPtr = std::shared_ptr<SubGrad>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/gru.h

@@ -66,7 +66,6 @@ class MS_CORE_API GRU : public PrimitiveC {
   GateOrderMode get_gate_order() const;
 };
 
-using PrimGRUPtr = std::shared_ptr<GRU>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/hashtable_lookup.h

@@ -35,7 +35,6 @@ class MS_CORE_API HashtableLookup : public PrimitiveC {
 
 AbstractBasePtr HashtableLookupInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                      const std::vector<AbstractBasePtr> &input_args);
-using PrimHashtableLookupPtr = std::shared_ptr<HashtableLookup>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/hshrink.h

@@ -35,7 +35,6 @@ class MS_CORE_API HShrink : public PrimitiveC {
 
 AbstractBasePtr HShrinkInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                              const std::vector<AbstractBasePtr> &input_args);
-using PrimHShrinkPtr = std::shared_ptr<HShrink>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_HSHRINK_H

mindspore/core/ops/hsigmoid.h

@@ -36,7 +36,6 @@ class MS_CORE_API HSigmoid : public PrimitiveC {
 AbstractBasePtr HSigmoidInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                               const std::vector<AbstractBasePtr> &input_args);
 
-using PrimHSigmoidPtr = std::shared_ptr<HSigmoid>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/identity.h

@@ -32,7 +32,6 @@ class MS_CORE_API Identity : public PrimitiveC {
   MS_DECLARE_PARENT(Identity, PrimitiveC);
   void Init() {}
 };
-using PrimIdentityPtr = std::shared_ptr<Identity>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/index_add.h

@@ -38,7 +38,6 @@ class IndexAdd : public PrimitiveC {
 AbstractBasePtr IndexAddInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                               const std::vector<AbstractBasePtr> &input_args);
 
-using PrimIndexAddPtr = std::shared_ptr<IndexAdd>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/invert_permutation.h

@@ -32,7 +32,6 @@ class MS_CORE_API InvertPermutation : public PrimitiveC {
   MS_DECLARE_PARENT(InvertPermutation, PrimitiveC);
 };
 
-using PrimInvertPermutationPtr = std::shared_ptr<InvertPermutation>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/l2_normalize.h

@@ -40,7 +40,6 @@ class MS_CORE_API L2Normalize : public PrimitiveC {
 };
 AbstractBasePtr L2NormalizeInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                  const std::vector<AbstractBasePtr> &input_args);
-using PrimL2NormalizePtr = std::shared_ptr<L2Normalize>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_L2_NORMALIZE_H_

mindspore/core/ops/leaky_relu.h

@@ -40,7 +40,6 @@ class MS_CORE_API LeakyRelu : public PrimitiveC {
 
 AbstractBasePtr LeakyReluInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                                const std::vector<AbstractBasePtr> &input_args);
-using PrimLeakyReluPtr = std::shared_ptr<LeakyRelu>;
 }  // namespace ops
 }  // namespace mindspore
 

mindspore/core/ops/lerp.h

@@ -36,7 +36,6 @@ class Lerp : public PrimitiveC {
 
 AbstractBasePtr LerpInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr &primitive,
                           const std::vector<AbstractBasePtr> &input_args);
-using PrimLerpPtr = std::shared_ptr<Lerp>;
 }  // namespace ops
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_OPS_LERP_H_